@sbb-esta/lyne-elements-experimental 3.1.0 → 3.3.0

package/development/seat-reservation/seat-reservation/seat-reservation.component.js

@@ -1,25 +1,19 @@
-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 { __esDecorate, __runInitializers } from "tslib";
 import { SbbLanguageController } from "@sbb-esta/lyne-elements/core/controllers.js";
-import { forceType } from "@sbb-esta/lyne-elements/core/decorators.js";
-import { css, html, nothing } from "lit";
-import { customElement, property } from "lit/decorators.js";
+import { css, isServer, html, nothing } from "lit";
+import { customElement } from "lit/decorators.js";
 import { classMap } from "lit/directives/class-map.js";
 import { styleMap } from "lit/directives/style-map.js";
 import { getI18nSeatReservation } from "../common.js";
 import { SeatReservationBaseElement } from "./seat-reservation-base-element.js";
+import "@sbb-esta/lyne-elements/button.js";
 import "@sbb-esta/lyne-elements/screen-reader-only.js";
 import "../seat-reservation-area.js";
 import "../seat-reservation-graphic.js";
 import "../seat-reservation-place-control.js";
 import "../seat-reservation-navigation-coach.js";
 import "../seat-reservation-scoped.js";
+import "@sbb-esta/lyne-elements/popover/popover.js";
 const style = css`*,
 ::before,
 ::after {
@@ -28,8 +22,10 @@ const style = css`*,
 
 :host {
   --sbb-seat-reservation-grid-size: 16px;
-  --sbb-seat-reservation-vertical-offset: 0;
+  --sbb-seat-reservation-height: 0;
+  --sbb-seat-reservation-decks: 1;
   display: block;
+  height: inherit;
 }
 :host ::part(coach-floor) {
   fill: var(--sbb-color-white);
@@ -40,29 +36,124 @@ const style = css`*,
   }
 }
 
-.sbb-sr__wrapper--vertical {
-  width: fit-content;
-  position: relative;
-  inset-inline-start: var(--sbb-seat-reservation-vertical-offset);
-  rotate: 90deg;
-  transform-origin: top left;
+:host(:dir(rtl)) :not(.sbb-sr-place-ctrl--type-bicycle,
+.sbb-sr-place-ctrl--orientation-90,
+.sbb-sr-place-ctrl--orientation-270,
+.sbb-sr-place-ctrl--state-selected) ::part(coach-floor) {
+  rotate: calc(180 * 1deg);
 }
 
-.sbb-sr__wrapper--vertical .sbb-sr__parent {
-  overflow-y: hidden;
+[popover]:where(sbb-popover) {
+  margin: 0;
+  padding: 0;
+  border: none;
+  width: auto;
+  height: auto;
+  background-color: transparent;
+  color: inherit;
+  pointer-events: none;
 }
 
-.sbb-sr__wrapper--vertical .sbb-sr__list-coaches {
-  width: 100vw;
+.sbb-sr__container {
+  display: flex;
+  height: inherit;
 }
 
-.sbb-sr-navigation--vertical {
-  inset-inline-start: var(--sbb-seat-reservation-vertical-offset);
-  margin-inline-start: 1.25rem;
+.sbb-sr__grid {
+  display: grid;
+  grid-template-columns: 20% 1fr 20%;
+  grid-template-rows: auto auto;
+}
+.sbb-sr__grid .sbb-sr-navigation-first-grid,
+.sbb-sr__grid .sbb-sr-navigation-last-grid {
+  grid-row-start: 1;
+  position: relative;
+}
+.sbb-sr__grid .sbb-sr-navigation-first-grid {
+  grid-column: 1/2;
+}
+.sbb-sr__grid .sbb-sr-navigation-last-grid {
+  grid-column: 3/4;
+}
+.sbb-sr__grid .sbb-sr__component {
+  display: flex;
+  grid-column: 1/4;
+  grid-row: 1/3;
+}
+.sbb-sr__grid .sbb-sr-grid-inner {
+  display: grid;
+  grid-template-columns: 20% 60% 20%;
+  grid-template-rows: auto 1fr;
+  grid-gap: 0;
+}
+.sbb-sr__grid .sbb-sr-grid-inner .nav-grid {
+  grid-column: 2/3;
+  grid-row: 1/2;
+  display: inherit;
+}
+.sbb-sr__grid .sbb-sr-grid-inner .coaches-grid {
+  grid-column: 1/4;
+  grid-row: 2/3;
+  display: inherit;
+}
+
+.sbb-sr__navigation-control-button {
   position: absolute;
+  z-index: 10;
 }
-.sbb-sr-navigation--vertical .sbb-sr-navigation__list-coaches {
-  flex-direction: column;
+.sbb-sr__navigation-control-button#first-tab-element {
+  inset-inline-end: calc(8 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+.sbb-sr__navigation-control-button#last-tab-element {
+  inset-inline-start: calc(8 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr-navigation-wrapper {
+  overflow: hidden;
+  padding-block: 0 calc(32 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr-navigation {
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: var(--sbb-color-black-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-black-alpha-60);
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+}
+.sbb-sr-navigation::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr-navigation::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr-navigation::-webkit-scrollbar-thumb {
+  background-color: var(--sbb-scrollbar-color, currentcolor);
+  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;
+  border-radius: var(--sbb-border-radius-4x);
+  background-clip: padding-box;
+}
+.sbb-sr-navigation::-webkit-scrollbar-thumb:hover {
+  background-color: var(--sbb-scrollbar-color-hover, currentcolor);
+  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));
+}
+.sbb-sr-navigation::-webkit-scrollbar-button, .sbb-sr-navigation::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-sr-navigation {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+.sbb-sr-navigation {
+  --sbb-scrollbar-color: var(--sbb-color-white-alpha-0);
+  display: flex;
+  overflow: scroll hidden;
+  position: relative;
 }
 
 .sbb-sr-navigation__list-coaches {
@@ -71,72 +162,244 @@ const style = css`*,
   padding: 0;
   font-size: inherit;
   display: flex;
-  justify-content: center;
   flex-wrap: nowrap;
-  gap: var(--sbb-spacing-fixed-1x);
-  min-height: 3.75rem;
+  gap: calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  padding: calc(2 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
 }
 
-.sbb-sr__parent {
-  overflow-x: scroll;
-  padding: 3rem 0;
+.sbb-sr__wrapper-coach-decks {
+  display: flex;
+  overflow: hidden;
+  height: inherit;
+}
+.sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels {
+  display: flex;
+  justify-content: space-between;
+  height: calc(var(--sbb-seat-reservation-height) * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  writing-mode: vertical-lr;
+}
+.sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels b {
+  height: calc(50% - 16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  width: calc(20 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  margin-block-end: 16px;
+  rotate: 180deg;
+  text-align: center;
+  line-height: calc(20 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
 }
 
-.sbb-sr__list-coaches {
+.sbb-sr__wrapper {
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: var(--sbb-color-black-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-black-alpha-60);
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+}
+.sbb-sr__wrapper::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr__wrapper::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr__wrapper::-webkit-scrollbar-thumb {
+  background-color: var(--sbb-scrollbar-color, currentcolor);
+  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;
+  border-radius: var(--sbb-border-radius-4x);
+  background-clip: padding-box;
+}
+.sbb-sr__wrapper::-webkit-scrollbar-thumb:hover {
+  background-color: var(--sbb-scrollbar-color-hover, currentcolor);
+  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));
+}
+.sbb-sr__wrapper::-webkit-scrollbar-button, .sbb-sr__wrapper::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-sr__wrapper {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+.sbb-sr__wrapper {
+  overflow-x: scroll;
+  padding-block: calc(8 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+.sbb-sr__wrapper .sbb-sr__parent {
   display: flex;
-  gap: 0.25rem;
-  padding: 0;
+  flex-direction: column;
+  position: relative;
+}
+
+.sbb-sr__list-decks {
+  list-style: none;
   margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  flex-direction: column;
+}
+
+.sbb-sr__list-decks--gap {
+  gap: calc(48 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+
+.sbb-sr__list-item-deck {
+  position: relative;
+}
+
+.sbb-sr__list-coaches {
   list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  gap: calc(4 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
 }
 
 .sbb-sr__item-coach {
-  padding: 0;
-  margin: 0;
   position: relative;
 }
 
+.sbb-sr-popover {
+  margin: 0;
+}
+
 .sbb-sr-coach-wrapper__table {
   outline: 0;
+}
+
+.sbb-sr.sbb-sr__grid--vertical {
+  grid-template-columns: calc((var(--sbb-seat-reservation-height) + 24) * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) 1fr;
+  grid-template-rows: 20% 60% 20%;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-navigation-first-grid {
+  grid-column: 2/3;
+  grid-row-start: 1;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-navigation-first-grid #first-tab-element {
+  position: absolute;
+  inset-block-end: calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  inset-inline-start: calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  inset-inline-end: initial;
+  rotate: 90deg;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-navigation-last-grid {
+  grid-column: 2/3;
+  grid-row: 3/4;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-navigation-last-grid #last-tab-element {
+  inset-block-start: calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  inset-inline-start: calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  rotate: 90deg;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-navigation-wrapper {
+  padding-block-end: initial;
+  padding-inline-start: calc(16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr__component {
+  grid-column: 1/3;
+  grid-row: 1/4;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner {
+  grid-template-columns: calc((var(--sbb-seat-reservation-height) + 24) * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) 1fr;
+  grid-template-rows: 20% 60% 20%;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .nav-grid {
+  grid-column: 2/3;
+  grid-row: 2/3;
+  height: 100%;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .nav-grid .sbb-sr-navigation {
+  display: block;
+  overflow: hidden scroll;
+  height: 100%;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .nav-grid .sbb-sr-navigation .sbb-sr-navigation__list-coaches {
+  flex-direction: column;
+  padding: calc(2 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid {
+  grid-column: 1/2;
+  grid-row: 1/4;
+  overflow: hidden;
+  position: relative;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks {
+  flex-direction: column;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels {
+  flex-direction: column-reverse;
+  width: calc(100% - 24 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  height: initial;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper-deck-labels b {
+  width: calc(50% - 16 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  height: calc(20 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
+  margin-bottom: 16px;
+  rotate: initial;
+  writing-mode: initial;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper {
+  --sbb-scrollbar-thumb-width: 0.125rem;
+  --sbb-scrollbar-thumb-width-hover: 0.25rem;
+  --sbb-scrollbar-width-firefox: thin;
+  --sbb-scrollbar-color: var(--sbb-color-black-alpha-30);
+  --sbb-scrollbar-color-hover: var(--sbb-color-black-alpha-60);
+  --sbb-scrollbar-track-color: transparent;
+  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper::-webkit-scrollbar {
+  width: var(--sbb-scrollbar-width);
+  height: var(--sbb-scrollbar-width);
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper::-webkit-scrollbar-corner {
+  background-color: var(--sbb-scrollbar-track-color, transparent);
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper::-webkit-scrollbar-thumb {
+  background-color: var(--sbb-scrollbar-color, currentcolor);
+  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;
+  border-radius: var(--sbb-border-radius-4x);
+  background-clip: padding-box;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper::-webkit-scrollbar-thumb:hover {
+  background-color: var(--sbb-scrollbar-color-hover, currentcolor);
+  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper::-webkit-scrollbar-button, .sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper::-webkit-scrollbar-corner {
+  display: none;
+}
+@supports not selector(::-webkit-scrollbar) {
+  .sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper {
+    scrollbar-width: var(--sbb-scrollbar-width-firefox);
+    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);
+  }
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__wrapper {
+  overflow: hidden scroll;
+  height: 100%;
+  padding: 0;
+}
+.sbb-sr.sbb-sr__grid--vertical .sbb-sr-grid-inner .coaches-grid .sbb-sr__wrapper-coach-decks .sbb-sr__parent {
+  rotate: 90deg;
+  transform-origin: calc((var(--sbb-seat-reservation-height) + 24 - 24 - 6 * (var(--sbb-seat-reservation-decks) - 1)) / 2 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem)) calc((var(--sbb-seat-reservation-height) + 24 - 24 - 6 * (var(--sbb-seat-reservation-decks) - 1)) / 2 * var(--sbb-seat-reservation-one-px-rem, 0.0625rem));
 }`;
 let SbbSeatReservationElement = (() => {
-  var _seatReservation_accessor_storage, _hasNavigation_accessor_storage, _alignVertical_accessor_storage, _maxReservations_accessor_storage, _preventPlaceClick_accessor_storage, _a;
+  var _a;
   let _classDecorators = [customElement("sbb-seat-reservation")];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
   let _classSuper = SeatReservationBaseElement;
-  let _seatReservation_decorators;
-  let _seatReservation_initializers = [];
-  let _seatReservation_extraInitializers = [];
-  let _hasNavigation_decorators;
-  let _hasNavigation_initializers = [];
-  let _hasNavigation_extraInitializers = [];
-  let _alignVertical_decorators;
-  let _alignVertical_initializers = [];
-  let _alignVertical_extraInitializers = [];
-  let _maxReservations_decorators;
-  let _maxReservations_initializers = [];
-  let _maxReservations_extraInitializers = [];
-  let _preventPlaceClick_decorators;
-  let _preventPlaceClick_initializers = [];
-  let _preventPlaceClick_extraInitializers = [];
   _a = class extends _classSuper {
     constructor() {
       super(...arguments);
-      __privateAdd(this, _seatReservation_accessor_storage);
-      __privateAdd(this, _hasNavigation_accessor_storage);
-      __privateAdd(this, _alignVertical_accessor_storage);
-      __privateAdd(this, _maxReservations_accessor_storage);
-      __privateAdd(this, _preventPlaceClick_accessor_storage);
-      __privateSet(this, _seatReservation_accessor_storage, __runInitializers(this, _seatReservation_initializers, null));
-      __privateSet(this, _hasNavigation_accessor_storage, (__runInitializers(this, _seatReservation_extraInitializers), __runInitializers(this, _hasNavigation_initializers, true)));
-      __privateSet(this, _alignVertical_accessor_storage, (__runInitializers(this, _hasNavigation_extraInitializers), __runInitializers(this, _alignVertical_initializers, false)));
-      __privateSet(this, _maxReservations_accessor_storage, (__runInitializers(this, _alignVertical_extraInitializers), __runInitializers(this, _maxReservations_initializers, null)));
-      __privateSet(this, _preventPlaceClick_accessor_storage, (__runInitializers(this, _maxReservations_extraInitializers), __runInitializers(this, _preventPlaceClick_initializers, false)));
-      this._language = (__runInitializers(this, _preventPlaceClick_extraInitializers), new SbbLanguageController(this));
+      this._language = new SbbLanguageController(this);
       this._notAreaElements = [
-        "DRIVER_AREA_FULL",
+        "DRIVER_AREA",
         "COACH_PASSAGE",
         "COACH_WALL_NO_PASSAGE",
         "COMPARTMENT_PASSAGE",
@@ -146,41 +409,6 @@ let SbbSeatReservationElement = (() => {
       ];
       this._notFixedRotatableAreaIcons = ["ENTRY_EXIT"];
     }
-    /** The seat reservation object which contains all coaches and places */
-    get seatReservation() {
-      return __privateGet(this, _seatReservation_accessor_storage);
-    }
-    set seatReservation(value) {
-      __privateSet(this, _seatReservation_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);
-    }
-    /** Controls the visual representation of seat reservation in a horizonal or vertical alignment */
-    get alignVertical() {
-      return __privateGet(this, _alignVertical_accessor_storage);
-    }
-    set alignVertical(value) {
-      __privateSet(this, _alignVertical_accessor_storage, value);
-    }
-    /** Maximal number of possible clickable seats */
-    get maxReservations() {
-      return __privateGet(this, _maxReservations_accessor_storage);
-    }
-    set maxReservations(value) {
-      __privateSet(this, _maxReservations_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);
-    }
     willUpdate(changedProperties) {
       super.willUpdate(changedProperties);
       if (changedProperties.has("hasNavigation")) {
@@ -193,148 +421,211 @@ let SbbSeatReservationElement = (() => {
     }
     firstUpdated(changedProperties) {
       super.firstUpdated(changedProperties);
-      this._componentSetup();
+      this.updateComplete.then(() => {
+        this.initPrepairSeatReservationData();
+        this.initNavigationSelectionByScrollEvent();
+        this.requestUpdate();
+      });
     }
     render() {
+      if (!isServer) {
+        this._determineBaseFontSize();
+      }
       this._initVehicleSeatReservationConstruction();
       return this._coachesHtmlTemplate || null;
     }
-    _componentSetup() {
-      this.initNavigationSelectionByScrollEvent();
+    _determineBaseFontSize() {
+      const baseFontSize = parseInt(window.getComputedStyle(document.body).fontSize, 10);
+      const onePixelInRem = 1 / baseFontSize;
+      this.style?.setProperty("--sbb-seat-reservation-one-px-rem", `${onePixelInRem + "rem"}`);
     }
     _initVehicleSeatReservationConstruction() {
-      const coachItems = JSON.parse(JSON.stringify(this.seatReservation?.coachItems));
-      const classAlignVertical = this.alignVertical ? "sbb-sr__wrapper--vertical" : "";
+      const classAlignVertical = this.alignVertical ? "sbb-sr__grid--vertical" : "";
       this._coachesHtmlTemplate = html`
-      <div>
-        <sbb-screen-reader-only>
-          <input
-            id="first-tab-element"
-            role="contentinfo"
-            type="text"
-            aria-label="${getI18nSeatReservation("SEAT_RESERVATION_BEGIN", this._language.current)}"
-            readonly
-          />
-        </sbb-screen-reader-only>
-
-        <div @keydown=${(evt) => this.handleKeyboardEvent(evt)}>
-          ${this._renderNavigation()}
-          <div class="sbb-sr__wrapper ${classAlignVertical}">
-            <div id="sbb-sr__parent-area" class="sbb-sr__parent" tabindex="-1">
-              <ul class="sbb-sr__list-coaches" role="presentation">
-                ${this._renderCoaches(coachItems)}
-              </ul>
+      <div class="sbb-sr__container">
+        <div class="sbb-sr sbb-sr__grid ${classAlignVertical}">
+          <div class="sbb-sr-navigation-first-grid">
+            ${this._renderNavigationControlButton("DIRECTION_LEFT")}
+          </div>
+          <div
+            class="sbb-sr__component"
+            @keydown=${(evt) => this.handleKeyboardEvent(evt)}
+          >
+            <div class="sbb-sr-grid-inner">
+              <div class="nav-grid">${this._renderNavigation()}</div>
+              <div class="coaches-grid">
+                <div class="sbb-sr__wrapper-coach-decks">
+                  <div class="sbb-sr__wrapper-deck-labels">${this._renderDeckLabels()}</div>
+                  <div id="sbb-sr__wrapper-scrollarea" class="sbb-sr__wrapper">
+                    <div id="sbb-sr__parent-area" class="sbb-sr__parent" tabindex="-1">
+                      <ul
+                        class="${classMap({
+        "sbb-sr__list-decks": true,
+        "sbb-sr__list-decks--gap": this.hasMultipleDecks
+      })}"
+                      >
+                        ${this.seatReservations?.map((seatReservation, index) => {
+        return html`<li class="sbb-sr__list-item-deck">
+                              <ul class="sbb-sr__list-coaches" role="presentation">
+                                ${this._renderCoaches(seatReservation, index)}
+                              </ul>
+                            </li>`;
+      })}
+                      </ul>
+                    </div>
+                  </div>
+                </div>
+              </div>
             </div>
           </div>
+          <div class="sbb-sr-navigation-last-grid">
+            ${this._renderNavigationControlButton("DIRECTION_RIGHT")}
+          </div>
         </div>
-
-        <sbb-screen-reader-only>
-          <input
-            id="last-tab-element"
-            role="contentinfo"
-            type="text"
-            aria-label="${getI18nSeatReservation("SEAT_RESERVATION_END", this._language.current)}"
-            readonly
-          />
-        </sbb-screen-reader-only>
       </div>
     `;
     }
-    _renderNavigation() {
-      if (!this.hasNavigation) {
+    _renderDeckLabels() {
+      if (!this.hasMultipleDecks)
         return null;
+      return this.seatReservations.map((seatReservation) => {
+        const deckDescription = getI18nSeatReservation(seatReservation.deckCoachLevel, this._language.current);
+        return html`<b aria-hidden="true">${deckDescription}</b>`;
+      });
+    }
+    _renderNavigationControlButton(btnDirection) {
+      if (!this.hasNavigation || !this.seatReservations)
+        return null;
+      const btnId = btnDirection == "DIRECTION_RIGHT" ? "last-tab-element" : "first-tab-element";
+      const btnIcon = btnDirection == "DIRECTION_RIGHT" ? "arrow-right-small" : "arrow-left-small";
+      const btnAriaDescription = btnDirection == "DIRECTION_RIGHT" ? getI18nSeatReservation("SEAT_RESERVATION_END", this._language.current) : getI18nSeatReservation("SEAT_RESERVATION_BEGIN", this._language.current);
+      let btnDisabled = true;
+      if (btnDirection == "DIRECTION_LEFT" && this.selectedCoachIndex > 0) {
+        btnDisabled = false;
+      } else if (btnDirection == "DIRECTION_RIGHT" && this.selectedCoachIndex < this.seatReservations[this.currSelectedDeckIndex].coachItems.length - 1) {
+        btnDisabled = false;
       }
-      return html`
-      <nav class="${classMap({ "sbb-sr-navigation--vertical": this.alignVertical })}">
+      return html`<sbb-secondary-button
+      @click="${() => this.navigateByDirectionBtn(btnDirection)}"
+      id="${btnId}"
+      class="sbb-sr__navigation-control-button"
+      size="s"
+      icon-name="${btnIcon}"
+      type="button"
+      aria-label="${btnAriaDescription}"
+      role="contentinfo"
+      .disabledInteractive="${btnDisabled || nothing}"
+    ></sbb-secondary-button>`;
+    }
+    _renderNavigation() {
+      if (!this.hasNavigation || !this.seatReservations)
+        return null;
+      return html`<div class="sbb-sr-navigation-wrapper">
+      <nav id="sbb-sr-navigation" class="sbb-sr-navigation">
         <ul
+          id="sbb-sr__navigation-list-coaches"
           class="sbb-sr-navigation__list-coaches"
           aria-label="${getI18nSeatReservation("SEAT_RESERVATION_NAVIGATION", this._language.current)}"
         >
-          ${this.seatReservation?.coachItems.map((coachItem, index) => {
+          ${this.seatReservations[this.currSelectedDeckIndex]?.coachItems.map((coachItem, index) => {
+        const coachFreePlaces = this.getAvailableFreePlacesNumFromCoach(index);
         return html`<li>
-              <sbb-seat-reservation-navigation-coach
-                @selectcoach=${(event) => this._onSelectNavCoach(event)}
-                @focuscoach=${() => this._onFocusNavCoach()}
-                index="${index}"
-                coach-id="${coachItem.id}"
-                .selected=${this.selectedCoachIndex === index}
-                .focused=${this.focusedCoachIndex === index}
-                .propertyIds="${coachItem.propertyIds}"
-                .travelClass="${coachItem.travelClass}"
-                ?driver-area="${!coachItem.places?.length}"
-                ?first="${index === 0}"
-                ?last="${index === this.seatReservation?.coachItems.length - 1}"
-                ?vertical="${this.alignVertical}"
-              >
-              </sbb-seat-reservation-navigation-coach>
-            </li>`;
+                <sbb-seat-reservation-navigation-coach
+                  @selectcoach=${(event) => this._onSelectNavCoach(event)}
+                  @focuscoach=${() => this._onFocusNavCoach()}
+                  class="${classMap({
+          "sbb-sr__navigation-coach--hover-scroll": this.hoveredScrollCoachIndex === index
+        })}"
+                  index="${index}"
+                  coach-id="${coachItem.id}"
+                  .freePlacesByType="${coachFreePlaces}"
+                  .selected=${this.selectedCoachIndex === index}
+                  .focused=${this.focusedCoachIndex === index}
+                  .propertyIds="${coachItem.propertyIds}"
+                  .travelClass="${coachItem.travelClass}"
+                  ?driver-area="${!coachItem.places?.length}"
+                  ?first="${coachItem?.driverAreaSide?.left}"
+                  ?last="${coachItem?.driverAreaSide?.right}"
+                  ?vertical="${this.alignVertical}"
+                >
+                </sbb-seat-reservation-navigation-coach>
+              </li>`;
       })}
         </ul>
       </nav>
-    `;
+    </div>`;
     }
     /**
      *
      * @param coaches
      * @returns
      */
-    _renderCoaches(coaches) {
+    _renderCoaches(seatReservation, deckIndex) {
+      const coaches = JSON.parse(JSON.stringify(seatReservation?.coachItems));
       if (!coaches) {
         return null;
       }
-      return coaches.map((coachItem, index) => {
+      return coaches.map((coachItem, coachIndex) => {
         return html`
-        <li class="sbb-sr__item-coach">${this._renderCoachElement(coachItem, index)}</li>
+        <li class="sbb-sr__item-coach">
+          ${this._renderCoachElement(coachItem, coachIndex, deckIndex)}
+        </li>
       `;
       });
     }
-    _renderCoachElement(coachItem, index) {
+    _renderCoachElement(coachItem, coachIndex, coachDeckIndex) {
       const calculatedCoachDimension = this.getCalculatedDimension(coachItem.dimension);
-      const descriptionTableCoachWithServices = this._getDescriptionTableCoach(coachItem);
-      return html` <sbb-seat-reservation-scoped
-      scoped-classes="coach-wrapper"
-      height="${calculatedCoachDimension.h}px"
-      width="${calculatedCoachDimension.w}px"
+      const descriptionTableCoachWithServices = this._getDescriptionTableCoach(coachItem, coachIndex);
+      return html`<sbb-seat-reservation-scoped
+      style=${styleMap({
+        "--sbb-seat-reservation-scoped-width": calculatedCoachDimension.w,
+        "--sbb-seat-reservation-scoped-height": calculatedCoachDimension.h
+      })}
     >
-      ${this._getRenderedCoachBorders(coachItem, index)}
-      ${this._getRenderedGraphicalElements(coachItem.graphicElements || [], coachItem.dimension)}
-      ${this._getRenderedServiceElements(coachItem.serviceElements)}
+      ${this._getRenderedCoachBorders(coachItem)}
+      ${this._getRenderedGraphicalElements(coachItem.graphicElements || [], coachItem.dimension, coachIndex, coachDeckIndex)}
+      ${this._getRenderedServiceElements(coachIndex, coachDeckIndex, coachItem.serviceElements)}
+
       <table
-        @focus=${() => this.onFocusTableCoachAndPreselectPlace(index)}
-        id="sbb-sr-coach-${index}"
+        @focus=${() => this.onFocusTableCoachAndPreselectPlace(coachIndex)}
+        id="sbb-sr-coach-${coachIndex}"
         class="sbb-sr-coach-wrapper__table"
-        aria-describedby="sbb-sr-coach-caption-${index}"
+        aria-describedby="sbb-sr-coach-caption-${coachIndex}"
       >
-        <caption id="sbb-sr-coach-caption-${index}" tabindex="-1">
+        <caption id="sbb-sr-coach-caption-${coachIndex}" tabindex="-1">
           <sbb-screen-reader-only>${descriptionTableCoachWithServices}</sbb-screen-reader-only>
         </caption>
-        ${this._getRenderedRowPlaces(coachItem, index)}
+        ${this._getRenderedRowPlaces(coachItem, coachIndex, coachDeckIndex)}
       </table>
     </sbb-seat-reservation-scoped>`;
     }
-    _getRenderedCoachBorders(coachItem, coachIndex) {
-      const allElements = coachItem.graphicElements;
+    /**
+     * @returns Returns the border graphic (COACH_BORDER_MIDDLE) of a coach with calculated border gap and coach width,
+     * depending on whether the coach is with a driver area or without.
+     */
+    _getRenderedCoachBorders(coachItem) {
       const COACH_PASSAGE_WIDTH = 1;
-      const driverArea = allElements?.find((element) => element.icon === "DRIVER_AREA_FULL");
+      const allElements = coachItem.graphicElements;
+      const driverArea = allElements?.find((element) => element.icon === "DRIVER_AREA");
       const borderWidth = driverArea ? coachItem.dimension.w - driverArea.dimension.w - COACH_PASSAGE_WIDTH : coachItem.dimension.w - COACH_PASSAGE_WIDTH * 2;
-      const borderOffsetX = coachIndex === 0 && driverArea ? driverArea?.dimension.w * this.baseGridSize : this.baseGridSize;
+      const borderHeight = (coachItem.dimension.h + this.coachBorderOffset * 2) * this.baseGridSize;
+      const borderOffsetX = driverArea && driverArea.position.x === 0 ? driverArea?.dimension.w * this.baseGridSize : this.baseGridSize;
       return html`
-      <sbb-seat-reservation-scoped
-        scoped-classes="coach-border"
-        inset-block-start="${this.coachBorderPadding * -1}px"
-        inset-inline-start="${borderOffsetX}px"
-      >
-        <sbb-seat-reservation-graphic
-          name="COACH_BORDER_MIDDLE"
-          width=${borderWidth * this.baseGridSize}
-          height=${(coachItem.dimension.h + this.coachBorderOffset * 2) * this.baseGridSize}
-          ?stretch=${true}
-          role="presentation"
-        ></sbb-seat-reservation-graphic>
-      </sbb-seat-reservation-scoped>
+      <sbb-seat-reservation-graphic
+        style=${styleMap({
+        "--sbb-seat-reservation-graphic-width": borderWidth * this.baseGridSize,
+        "--sbb-seat-reservation-graphic-height": borderHeight,
+        "--sbb-seat-reservation-graphic-top": this.coachBorderPadding * -1,
+        "--sbb-seat-reservation-graphic-left": borderOffsetX,
+        "--sbb-seat-reservation-graphic-position": "absolute"
+      })}
+        name="COACH_BORDER_MIDDLE"
+        ?stretch=${true}
+        role="presentation"
+      ></sbb-seat-reservation-graphic>
     `;
     }
-    _getRenderedRowPlaces(coach, coachIndex) {
+    _getRenderedRowPlaces(coach, coachIndex, deckIndex) {
       if (!coach.places) {
         return null;
       }
@@ -349,31 +640,32 @@ let SbbSeatReservationElement = (() => {
       return Object.values(tableRowPlaces).map((rowPlaces, index) => {
         return html`
           <tr id="row-${coachIndex}-${rowPlaces[0].position.y}" data-row-index=${index}>
-            ${this._getRenderedColumnPlaces(rowPlaces, coachIndex)}
+            ${this._getRenderedColumnPlaces(rowPlaces, coachIndex, deckIndex)}
           </tr>
         `;
       }).flatMap((rowTemplate) => rowTemplate);
     }
-    _getRenderedColumnPlaces(places, coachIndex) {
+    _getRenderedColumnPlaces(places, coachIndex, deckIndex) {
       places.sort((placeA, placeB) => Number(placeA.position.x) - Number(placeB.position.x));
       return places?.map((place, index) => {
-        const calculatedInternalDimension = this.getCalculatedDimension(place.dimension);
-        const calculatedInternalPosition = this.getCalculatedPosition(place.position);
+        const calculatedDimension = this.getCalculatedDimension(place.dimension);
+        const calculatedPosition = this.getCalculatedPosition(place.position);
         const textRotation = this.alignVertical ? -90 : 0;
         return html`
-        <sbb-seat-reservation-scoped
-          scoped-classes="graphical-element"
-          inset-block-start="${calculatedInternalPosition.y}px"
-          inset-inline-start="${calculatedInternalPosition.x}px"
-          width="${calculatedInternalDimension.w}px"
-          height="${calculatedInternalDimension.h}px"
-          z-index="${place.position.z}"
-          cell-id="cell-${coachIndex}-${place.position.y}-${index}"
+        <td
+          id="cell-${deckIndex}-${coachIndex}-${place.position.y}-${index}"
+          class="graphical-element"
         >
           <sbb-seat-reservation-place-control
+            style=${styleMap({
+          "--sbb-seat-reservation-place-control-width": calculatedDimension.w,
+          "--sbb-seat-reservation-place-control-height": calculatedDimension.h,
+          "--sbb-seat-reservation-place-control-top": calculatedPosition.y,
+          "--sbb-seat-reservation-place-control-left": calculatedPosition.x
+        })}
             @selectplace=${(selectPlaceEvent) => this._onSelectPlace(selectPlaceEvent)}
             exportparts="sbb-sr-place-part"
-            id="seat-reservation__place-button-${coachIndex}-${place.number}"
+            id="seat-reservation__place-button-${deckIndex}-${coachIndex}-${place.number}"
             class="seat-reservation-place-control"
             data-cell-id="${coachIndex}-${place.position.y}-${index}"
             text=${place.number}
@@ -384,17 +676,17 @@ let SbbSeatReservationElement = (() => {
             rotation=${place.rotation ?? nothing}
             text-rotation=${textRotation}
             coach-index=${coachIndex}
+            deck-index=${deckIndex}
             .propertyIds=${place.propertyIds}
             .preventClick=${this.preventPlaceClick}
           ></sbb-seat-reservation-place-control>
-        </sbb-seat-reservation-scoped>
+        </td>
       `;
       });
     }
-    _getRenderedGraphicalElements(graphicalElements, coachDimension) {
-      if (!graphicalElements) {
+    _getRenderedGraphicalElements(graphicalElements, coachDimension, coachIndex, coachDeckIndex) {
+      if (!graphicalElements)
         return null;
-      }
       return graphicalElements?.map((graphicalElement) => {
         const icon = graphicalElement.icon ?? "";
         const elementRotation = graphicalElement.rotation || 0;
@@ -403,16 +695,25 @@ let SbbSeatReservationElement = (() => {
         if (this._notAreaElements.findIndex((notAreaElement) => notAreaElement === icon) > -1) {
           return this._getRenderElementWithoutArea(graphicalElement, elementRotation, coachDimension);
         }
-        return this._getRenderElementWithArea(graphicalElement, elementFixedRotation, coachDimension);
+        return this._getRenderElementWithArea(graphicalElement, elementFixedRotation, coachDimension, coachIndex, coachDeckIndex);
       });
     }
-    _getRenderElementWithArea(graphicalElement, rotation, coachDimension) {
-      const isNotTableGraphicTempFix = graphicalElement.icon?.indexOf("TABLE") === -1;
-      const areaProperty = graphicalElement.icon && isNotTableGraphicTempFix ? graphicalElement.icon : null;
+    /**
+     * creates a rendered element with an area component
+     * @param graphicalElement
+     * @param rotation
+     * @param coachDimension
+     * @param coachIndex used to generate a unique id for the popover trigger
+     * @private
+     */
+    _getRenderElementWithArea(graphicalElement, rotation, coachDimension, coachIndex, coachDeckIndex) {
+      const isNotTableGraphic = graphicalElement.icon?.indexOf("TABLE") === -1;
+      const areaProperty = graphicalElement.icon && isNotTableGraphic ? graphicalElement.icon : null;
       const stretchHeight = areaProperty !== "ENTRY_EXIT";
       const ariaLabelForArea = graphicalElement.icon ? getI18nSeatReservation(graphicalElement.icon, this._language.current) : nothing;
       const calculatedDimension = this.getCalculatedDimension(graphicalElement.dimension, coachDimension, true, stretchHeight);
       const calculatedPosition = this.getCalculatedPosition(graphicalElement.position, graphicalElement.dimension, coachDimension, true);
+      const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;
       let elementMounting = "free";
       if (graphicalElement.position.y === this.coachBorderOffset * -1) {
         elementMounting = "upper-border";
@@ -420,91 +721,78 @@ let SbbSeatReservationElement = (() => {
         elementMounting = "lower-border";
       }
       return html`
-      <sbb-seat-reservation-scoped
-        scoped-classes="graphical-element"
-        inset-block-start="${calculatedPosition.y}px"
-        inset-inline-start="${calculatedPosition.x}px"
-        width="${calculatedDimension.w}px"
-        height="${calculatedDimension.h}px"
-        z-index="${graphicalElement.position.z}"
-      >
-        <sbb-seat-reservation-area
-          style=${styleMap({
-        "--sbb-reservation-area-width": graphicalElement.dimension.w * this.baseGridSize,
-        "--sbb-reservation-area-height": graphicalElement.dimension.h * this.baseGridSize
+      <sbb-seat-reservation-area
+        id="${triggerId}"
+        class="${classMap({ "sbb-seat-reservation-area--cursor-pointer": areaProperty !== null })}"
+        style=${styleMap({
+        "--sbb-seat-reservation-area-width": calculatedDimension.w,
+        "--sbb-seat-reservation-area-height": calculatedDimension.h,
+        "--sbb-seat-reservation-area-top": calculatedPosition.y,
+        "--sbb-seat-reservation-area-left": calculatedPosition.x
       })}
-          mounting=${elementMounting}
-          background="dark"
-          aria-hidden="true"
-          title=${ariaLabelForArea}
-        >
-          ${areaProperty ? html`
-                <sbb-seat-reservation-graphic
-                  name=${areaProperty}
-                  rotation=${rotation}
-                  width=${this.baseGridSize}
-                  height=${this.baseGridSize}
-                  role="img"
-                  aria-hidden="true"
-                ></sbb-seat-reservation-graphic>
-              ` : nothing}
-        </sbb-seat-reservation-area>
-      </sbb-seat-reservation-scoped>
+        mounting=${elementMounting}
+        background="dark"
+        aria-hidden="true"
+      >
+        ${areaProperty ? html`
+              <sbb-seat-reservation-graphic
+                name=${areaProperty}
+                width=${this.baseGridSize}
+                height=${this.baseGridSize}
+                rotation=${rotation}
+                role="img"
+                aria-hidden="true"
+              ></sbb-seat-reservation-graphic>
+            ` : nothing}
+      </sbb-seat-reservation-area>
+      ${areaProperty ? this._popover(triggerId, ariaLabelForArea) : nothing}
     `;
     }
     _getRenderElementWithoutArea(graphicalElement, rotation, coachDimension) {
       const calculatedDimension = this.getCalculatedDimension(graphicalElement.dimension, coachDimension);
       const calculatedPosition = this.getCalculatedPosition(graphicalElement.position, graphicalElement.dimension, coachDimension);
-      const icon = graphicalElement.icon && graphicalElement.icon.indexOf("DRIVER_AREA") === -1 ? graphicalElement.icon : graphicalElement.icon?.concat("_", this.seatReservation.vehicleType);
-      return html`
-      <sbb-seat-reservation-scoped
-        scoped-classes="graphical-element"
-        inset-block-start="${calculatedPosition.y}px"
-        inset-inline-start="${calculatedPosition.x}px"
-        width="${calculatedDimension.w}px"
-        height="${calculatedDimension.h}px"
-        z-index="${graphicalElement.position.z}"
-      >
-        <sbb-seat-reservation-graphic
-          name=${icon ?? nothing}
-          width=${graphicalElement.dimension.w * this.baseGridSize}
-          height=${graphicalElement.dimension.h * this.baseGridSize}
-          rotation=${rotation}
-          aria-hidden="true"
-          ?stretch=${true}
-        ></sbb-seat-reservation-graphic>
-      </sbb-seat-reservation-scoped>
-    `;
+      const icon = graphicalElement.icon && graphicalElement.icon.indexOf("DRIVER_AREA") === -1 ? graphicalElement.icon : graphicalElement.icon?.concat("_", this.seatReservations[this.currSelectedDeckIndex].vehicleType);
+      return html` <sbb-seat-reservation-graphic
+      style=${styleMap({
+        "--sbb-seat-reservation-graphic-width": calculatedDimension.w,
+        "--sbb-seat-reservation-graphic-height": calculatedDimension.h,
+        "--sbb-seat-reservation-graphic-top": calculatedPosition.y,
+        "--sbb-seat-reservation-graphic-left": calculatedPosition.x,
+        "--sbb-seat-reservation-graphic-position": "absolute"
+      })}
+      name=${icon ?? nothing}
+      rotation=${rotation}
+      aria-hidden="true"
+      ?stretch=${true}
+    ></sbb-seat-reservation-graphic>`;
     }
-    _getRenderedServiceElements(serviceElements) {
-      if (!serviceElements) {
+    _getRenderedServiceElements(coachIndex, coachDeckIndex, serviceElements) {
+      if (!serviceElements)
         return null;
-      }
       return serviceElements?.map((serviceElement) => {
         const titleDescription = serviceElement.icon ? getI18nSeatReservation(serviceElement.icon, this._language.current) : null;
-        const calculatedcCmpartmentNumberDimension = this.getCalculatedDimension(serviceElement.dimension);
-        const calculatedcCmpartmentNumberPosition = this.getCalculatedPosition(serviceElement.position);
+        const calculatedDimension = this.getCalculatedDimension(serviceElement.dimension);
+        const calculatedPosition = this.getCalculatedPosition(serviceElement.position);
         const elementRotation = serviceElement.rotation || 0;
         const elementFixedRotation = this.alignVertical ? elementRotation - 90 : elementRotation;
+        const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;
         return html`
-        <sbb-seat-reservation-scoped
-          scoped-classes="graphical-element"
-          inset-block-start="${calculatedcCmpartmentNumberPosition.y}px"
-          inset-inline-start="${calculatedcCmpartmentNumberPosition.x}px"
-          width="${calculatedcCmpartmentNumberDimension.w}px"
-          height="${calculatedcCmpartmentNumberDimension.h}px"
-          z-index="${serviceElement.position.z}"
-        >
-          <sbb-seat-reservation-graphic
-            name=${serviceElement.icon ?? nothing}
-            width=${serviceElement.dimension.w * this.baseGridSize}
-            height=${serviceElement.dimension.h * this.baseGridSize}
-            .rotation=${elementFixedRotation}
-            role="img"
-            aria-hidden="true"
-            title=${titleDescription ?? nothing}
-          ></sbb-seat-reservation-graphic>
-        </sbb-seat-reservation-scoped>
+        <sbb-seat-reservation-graphic
+          id="${triggerId}"
+          style=${styleMap({
+          "--sbb-seat-reservation-graphic-width": calculatedDimension.w,
+          "--sbb-seat-reservation-graphic-height": calculatedDimension.h,
+          "--sbb-seat-reservation-graphic-top": calculatedPosition.y,
+          "--sbb-seat-reservation-graphic-left": calculatedPosition.x,
+          "--sbb-seat-reservation-graphic-position": "absolute"
+        })}
+          class="sbb-seat-reservation-graphic--cursor-pointer"
+          name=${serviceElement.icon ?? nothing}
+          .rotation=${elementFixedRotation}
+          role="img"
+          aria-hidden="true"
+        ></sbb-seat-reservation-graphic>
+        ${this._popover(triggerId, titleDescription)}
       `;
       });
     }
@@ -518,6 +806,7 @@ let SbbSeatReservationElement = (() => {
       this.preventCoachScrollByPlaceClick = true;
       this.isCoachGridFocusable = false;
       if (!this.preventPlaceClick) {
+        this.currSelectedDeckIndex = selectedPlace.deckIndex;
         this.updateSelectedSeatReservationPlaces(selectedPlace);
         this.updateCurrentSelectedPlaceInCoach(selectedPlace);
       }
@@ -532,6 +821,7 @@ let SbbSeatReservationElement = (() => {
         this.updateCurrentSelectedCoach();
         this.preselectPlaceInCoach();
       }
+      this._closePopover();
     }
     _onFocusNavCoach() {
       if (!this.preventCoachScrollByPlaceClick) {
@@ -541,18 +831,43 @@ let SbbSeatReservationElement = (() => {
       }
       this.isAutoScrolling = false;
     }
-    _getDescriptionTableCoach(coachItem) {
+    /**
+     * Creates a popover for extra service information
+     * @param triggerId
+     * @param popoverContent
+     * @private
+     */
+    _popover(triggerId, popoverContent) {
+      return html`
+      <sbb-popover trigger="${triggerId}">
+        <p class="sbb-text-s sbb-sr-popover">${popoverContent}</p>
+      </sbb-popover>
+    `;
+    }
+    /**
+     * trigger to close all opened popovers (normally only one is opened at a time)
+     * @private
+     */
+    _closePopover() {
+      this.shadowRoot?.querySelectorAll('sbb-popover[data-state="opened"]').forEach((popover) => popover.setAttribute("data-state", "closed"));
+    }
+    _getDescriptionTableCoach(coachItem, coachIndex) {
       if (!coachItem.places?.length) {
         return getI18nSeatReservation("COACH_BLOCKED_TABLE_CAPTION", this._language.current, [
           coachItem.id
         ]);
       }
-      let tableCoachDescription = "";
+      let tableCoachDescription;
       const areaDescriptions = this._getTitleDescriptionListString(coachItem.graphicElements);
       const serviceDescriptions = this._getTitleDescriptionListString(coachItem.serviceElements);
       tableCoachDescription = getI18nSeatReservation("COACH_TABLE_CAPTION", this._language.current, [
         coachItem.id
       ]);
+      if (!this.hasNavigation) {
+        const freePlaces = this.getAvailableFreePlacesNumFromCoach(coachIndex);
+        const freePlacesTxt = getI18nSeatReservation("COACH_AVAILABLE_NUMBER_OF_PLACES", this._language.current, [freePlaces.seats, freePlaces.bicycles]);
+        tableCoachDescription = tableCoachDescription.concat(". ").concat(freePlacesTxt).concat(". ");
+      }
       if (!!areaDescriptions || !!serviceDescriptions) {
         tableCoachDescription += ". " + getI18nSeatReservation("COACH_AVAILABLE_SERVICES", this._language.current) + ": ";
         tableCoachDescription += serviceDescriptions + ", " + areaDescriptions + ".";
@@ -574,28 +889,8 @@ let SbbSeatReservationElement = (() => {
         return !!translation && !descriptionAlreayExist && isValidDescription ? translation : null;
       }).filter((description) => !!description).join(", ");
     }
-  }, _seatReservation_accessor_storage = new WeakMap(), _hasNavigation_accessor_storage = new WeakMap(), _alignVertical_accessor_storage = new WeakMap(), _maxReservations_accessor_storage = new WeakMap(), _preventPlaceClick_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+  }, _classThis = _a, (() => {
     const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-    _seatReservation_decorators = [property({ attribute: "seat-reservation", type: Object })];
-    _hasNavigation_decorators = [forceType(), property({ attribute: "has-navigation", type: Boolean })];
-    _alignVertical_decorators = [forceType(), property({ attribute: "align-vertical", type: Boolean })];
-    _maxReservations_decorators = [forceType(), property({ attribute: "max-reservations", type: Number })];
-    _preventPlaceClick_decorators = [forceType(), property({ attribute: "prevent-place-click", type: Boolean })];
-    __esDecorate(_a, null, _seatReservation_decorators, { kind: "accessor", name: "seatReservation", static: false, private: false, access: { has: (obj) => "seatReservation" in obj, get: (obj) => obj.seatReservation, set: (obj, value) => {
-      obj.seatReservation = value;
-    } }, metadata: _metadata }, _seatReservation_initializers, _seatReservation_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, _maxReservations_decorators, { kind: "accessor", name: "maxReservations", static: false, private: false, access: { has: (obj) => "maxReservations" in obj, get: (obj) => obj.maxReservations, set: (obj, value) => {
-      obj.maxReservations = value;
-    } }, metadata: _metadata }, _maxReservations_initializers, _maxReservations_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(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
     _classThis = _classDescriptor.value;
     if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -605,4 +900,4 @@ let SbbSeatReservationElement = (() => {
 export {
   SbbSeatReservationElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"seat-reservation.component.js","sources":["../../../../../src/elements-experimental/seat-reservation/seat-reservation/seat-reservation.component.ts"],"sourcesContent":["import { SbbLanguageController } from '@sbb-esta/lyne-elements/core/controllers.js';\nimport { forceType } from '@sbb-esta/lyne-elements/core/decorators.js';\nimport { html, nothing } from 'lit';\nimport type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\nimport { classMap } from 'lit/directives/class-map.js';\nimport { styleMap } from 'lit/directives/style-map.js';\n\nimport { getI18nSeatReservation } from '../common.js';\nimport type {\n  CoachItem,\n  Place,\n  ElementDimension,\n  BaseElement,\n  PlaceSelection,\n  SeatReservation,\n} from '../common.js';\n\nimport { SeatReservationBaseElement } from './seat-reservation-base-element.js';\nimport style from './seat-reservation.scss?lit&inline';\n\nimport '@sbb-esta/lyne-elements/screen-reader-only.js';\nimport '../seat-reservation-area.js';\nimport '../seat-reservation-graphic.js';\nimport '../seat-reservation-place-control.js';\nimport '../seat-reservation-navigation-coach.js';\nimport '../seat-reservation-scoped.js';\n\n/**\n * Describe the purpose of the component with a single short sentence.\n */\nexport\n@customElement('sbb-seat-reservation')\nclass SbbSeatReservationElement extends SeatReservationBaseElement {\n  public static override styles: CSSResultGroup = style;\n\n  /** The seat reservation object which contains all coaches and places */\n  @property({ attribute: 'seat-reservation', type: Object })\n  public override accessor seatReservation: 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 override accessor hasNavigation: boolean = true;\n\n  /** Controls the visual representation of seat reservation in a horizonal or vertical alignment */\n  @forceType()\n  @property({ attribute: 'align-vertical', type: Boolean })\n  public override accessor alignVertical: boolean = false;\n\n  /** Maximal number of possible clickable seats */\n  @forceType()\n  @property({ attribute: 'max-reservations', type: Number })\n  public override accessor maxReservations: number = null!;\n\n  /** Any click functionality is prevented */\n  @forceType()\n  @property({ attribute: 'prevent-place-click', type: Boolean })\n  public override accessor preventPlaceClick: boolean = false;\n\n  private _language = new SbbLanguageController(this);\n  private _coachesHtmlTemplate?: TemplateResult;\n  // Graphics that should not be rendered with an area\n  private _notAreaElements = [\n    'DRIVER_AREA_FULL',\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  // Area icons that should not be fixed during rotation when vertical mode is selected\n  private _notFixedRotatableAreaIcons = ['ENTRY_EXIT'];\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('hasNavigation')) {\n      if (this.hasNavigation) {\n        this.shadowRoot\n          ?.querySelectorAll('table')\n          .forEach((table) => table.removeAttribute('tabindex'));\n      } else {\n        this.shadowRoot\n          ?.querySelectorAll('table')\n          .forEach((table) => table.setAttribute('tabindex', '0'));\n      }\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._componentSetup();\n  }\n\n  protected override render(): TemplateResult | null {\n    this._initVehicleSeatReservationConstruction();\n    return this._coachesHtmlTemplate || null;\n  }\n\n  private _componentSetup(): void {\n    this.initNavigationSelectionByScrollEvent();\n  }\n\n  private _initVehicleSeatReservationConstruction(): void {\n    const coachItems = JSON.parse(JSON.stringify(this.seatReservation?.coachItems));\n    const classAlignVertical = this.alignVertical ? 'sbb-sr__wrapper--vertical' : '';\n\n    this._coachesHtmlTemplate = html`\n      <div>\n        <sbb-screen-reader-only>\n          <input\n            id=\"first-tab-element\"\n            role=\"contentinfo\"\n            type=\"text\"\n            aria-label=\"${getI18nSeatReservation('SEAT_RESERVATION_BEGIN', this._language.current)}\"\n            readonly\n          />\n        </sbb-screen-reader-only>\n\n        <div @keydown=${(evt: KeyboardEvent) => this.handleKeyboardEvent(evt)}>\n          ${this._renderNavigation()}\n          <div class=\"sbb-sr__wrapper ${classAlignVertical}\">\n            <div id=\"sbb-sr__parent-area\" class=\"sbb-sr__parent\" tabindex=\"-1\">\n              <ul class=\"sbb-sr__list-coaches\" role=\"presentation\">\n                ${this._renderCoaches(coachItems)}\n              </ul>\n            </div>\n          </div>\n        </div>\n\n        <sbb-screen-reader-only>\n          <input\n            id=\"last-tab-element\"\n            role=\"contentinfo\"\n            type=\"text\"\n            aria-label=\"${getI18nSeatReservation('SEAT_RESERVATION_END', this._language.current)}\"\n            readonly\n          />\n        </sbb-screen-reader-only>\n      </div>\n    `;\n  }\n\n  private _renderNavigation(): TemplateResult | null {\n    if (!this.hasNavigation) {\n      return null;\n    }\n\n    return html`\n      <nav class=\"${classMap({ 'sbb-sr-navigation--vertical': this.alignVertical })}\">\n        <ul\n          class=\"sbb-sr-navigation__list-coaches\"\n          aria-label=\"${getI18nSeatReservation(\n            'SEAT_RESERVATION_NAVIGATION',\n            this._language.current,\n          )}\"\n        >\n          ${this.seatReservation?.coachItems.map((coachItem: CoachItem, index: number) => {\n            return html`<li>\n              <sbb-seat-reservation-navigation-coach\n                @selectcoach=${(event: CustomEvent<number>) => this._onSelectNavCoach(event)}\n                @focuscoach=${() => this._onFocusNavCoach()}\n                index=\"${index}\"\n                coach-id=\"${coachItem.id}\"\n                .selected=${this.selectedCoachIndex === index}\n                .focused=${this.focusedCoachIndex === index}\n                .propertyIds=\"${coachItem.propertyIds}\"\n                .travelClass=\"${coachItem.travelClass}\"\n                ?driver-area=\"${!coachItem.places?.length}\"\n                ?first=\"${index === 0}\"\n                ?last=\"${index === this.seatReservation?.coachItems.length - 1}\"\n                ?vertical=\"${this.alignVertical}\"\n              >\n              </sbb-seat-reservation-navigation-coach>\n            </li>`;\n          })}\n        </ul>\n      </nav>\n    `;\n  }\n  /**\n   *\n   * @param coaches\n   * @returns\n   */\n  private _renderCoaches(coaches?: CoachItem[]): TemplateResult[] | null {\n    if (!coaches) {\n      return null;\n    }\n    return coaches.map((coachItem: CoachItem, index: number) => {\n      return html`\n        <li class=\"sbb-sr__item-coach\">${this._renderCoachElement(coachItem, index)}</li>\n      `;\n    });\n  }\n\n  private _renderCoachElement(coachItem: CoachItem, index: number): TemplateResult {\n    const calculatedCoachDimension = this.getCalculatedDimension(coachItem.dimension);\n    const descriptionTableCoachWithServices = this._getDescriptionTableCoach(coachItem);\n\n    return html` <sbb-seat-reservation-scoped\n      scoped-classes=\"coach-wrapper\"\n      height=\"${calculatedCoachDimension.h}px\"\n      width=\"${calculatedCoachDimension.w}px\"\n    >\n      ${this._getRenderedCoachBorders(coachItem, index)}\n      ${this._getRenderedGraphicalElements(coachItem.graphicElements || [], coachItem.dimension)}\n      ${this._getRenderedServiceElements(coachItem.serviceElements)}\n      <table\n        @focus=${() => this.onFocusTableCoachAndPreselectPlace(index)}\n        id=\"sbb-sr-coach-${index}\"\n        class=\"sbb-sr-coach-wrapper__table\"\n        aria-describedby=\"sbb-sr-coach-caption-${index}\"\n      >\n        <caption id=\"sbb-sr-coach-caption-${index}\" tabindex=\"-1\">\n          <sbb-screen-reader-only>${descriptionTableCoachWithServices}</sbb-screen-reader-only>\n        </caption>\n        ${this._getRenderedRowPlaces(coachItem, index)}\n      </table>\n    </sbb-seat-reservation-scoped>`;\n  }\n\n  private _getRenderedCoachBorders(coachItem: CoachItem, coachIndex: number): TemplateResult {\n    const allElements = coachItem.graphicElements;\n    const COACH_PASSAGE_WIDTH = 1;\n    const driverArea = allElements?.find(\n      (element: BaseElement) => element.icon === 'DRIVER_AREA_FULL',\n    );\n    const borderWidth = driverArea\n      ? coachItem.dimension.w - driverArea.dimension.w - COACH_PASSAGE_WIDTH\n      : coachItem.dimension.w - COACH_PASSAGE_WIDTH * 2;\n    const borderOffsetX =\n      coachIndex === 0 && driverArea\n        ? driverArea?.dimension.w * this.baseGridSize\n        : this.baseGridSize;\n\n    return html`\n      <sbb-seat-reservation-scoped\n        scoped-classes=\"coach-border\"\n        inset-block-start=\"${this.coachBorderPadding * -1}px\"\n        inset-inline-start=\"${borderOffsetX}px\"\n      >\n        <sbb-seat-reservation-graphic\n          name=\"COACH_BORDER_MIDDLE\"\n          width=${borderWidth * this.baseGridSize}\n          height=${(coachItem.dimension.h + this.coachBorderOffset * 2) * this.baseGridSize}\n          ?stretch=${true}\n          role=\"presentation\"\n        ></sbb-seat-reservation-graphic>\n      </sbb-seat-reservation-scoped>\n    `;\n  }\n\n  private _getRenderedRowPlaces(coach: CoachItem, coachIndex: number): TemplateResult[] | null {\n    if (!coach.places) {\n      return null;\n    }\n\n    // Prepair rows with the places to render a table\n    const tableRowPlaces: Record<number, Place[]> = {};\n    for (const place of coach.places) {\n      if (!tableRowPlaces[place.position.y]) {\n        tableRowPlaces[place.position.y] = [place];\n      } else {\n        tableRowPlaces[place.position.y].push(place);\n      }\n    }\n\n    return Object.values(tableRowPlaces)\n      .map((rowPlaces: Place[], index) => {\n        return html`\n          <tr id=\"row-${coachIndex}-${rowPlaces[0].position.y}\" data-row-index=${index}>\n            ${this._getRenderedColumnPlaces(rowPlaces, coachIndex)}\n          </tr>\n        `;\n      })\n      .flatMap((rowTemplate) => rowTemplate);\n  }\n\n  private _getRenderedColumnPlaces(places: Place[], coachIndex: number): TemplateResult[] | null {\n    //Sorts each place by its ascending x coordinate\n    places.sort(\n      (placeA: Place, placeB: Place) => Number(placeA.position.x) - Number(placeB.position.x),\n    );\n\n    return places?.map((place: Place, index: number) => {\n      const calculatedInternalDimension = this.getCalculatedDimension(place.dimension);\n      const calculatedInternalPosition = this.getCalculatedPosition(place.position);\n      const textRotation = this.alignVertical ? -90 : 0;\n\n      return html`\n        <sbb-seat-reservation-scoped\n          scoped-classes=\"graphical-element\"\n          inset-block-start=\"${calculatedInternalPosition.y}px\"\n          inset-inline-start=\"${calculatedInternalPosition.x}px\"\n          width=\"${calculatedInternalDimension.w}px\"\n          height=\"${calculatedInternalDimension.h}px\"\n          z-index=\"${place.position.z}\"\n          cell-id=\"cell-${coachIndex}-${place.position.y}-${index}\"\n        >\n          <sbb-seat-reservation-place-control\n            @selectplace=${(selectPlaceEvent: CustomEvent<PlaceSelection>) =>\n              this._onSelectPlace(selectPlaceEvent)}\n            exportparts=\"sbb-sr-place-part\"\n            id=\"seat-reservation__place-button-${coachIndex}-${place.number}\"\n            class=\"seat-reservation-place-control\"\n            data-cell-id=\"${coachIndex}-${place.position.y}-${index}\"\n            text=${place.number}\n            type=${place.type}\n            state=${place.state}\n            width=${place.dimension.w * this.baseGridSize}\n            height=${place.dimension.h * this.baseGridSize}\n            rotation=${place.rotation ?? nothing}\n            text-rotation=${textRotation}\n            coach-index=${coachIndex}\n            .propertyIds=${place.propertyIds}\n            .preventClick=${this.preventPlaceClick}\n          ></sbb-seat-reservation-place-control>\n        </sbb-seat-reservation-scoped>\n      `;\n    });\n  }\n\n  private _getRenderedGraphicalElements(\n    graphicalElements: BaseElement[],\n    coachDimension: ElementDimension,\n  ): TemplateResult[] | null {\n    if (!graphicalElements) {\n      return null;\n    }\n\n    return graphicalElements?.map((graphicalElement: BaseElement) => {\n      const icon = graphicalElement.icon ?? '';\n      const elementRotation = graphicalElement.rotation || 0;\n      const isNotFixedRotationGraphicalElement =\n        this._notFixedRotatableAreaIcons.indexOf(graphicalElement.icon!) === -1;\n      const elementFixedRotation =\n        this.alignVertical && isNotFixedRotationGraphicalElement\n          ? elementRotation - 90\n          : elementRotation;\n\n      //check if the current element is not an area element, since this element is drawn without an area component\n      if (this._notAreaElements.findIndex((notAreaElement) => notAreaElement === icon) > -1) {\n        return this._getRenderElementWithoutArea(graphicalElement, elementRotation, coachDimension);\n      }\n      return this._getRenderElementWithArea(graphicalElement, elementFixedRotation, coachDimension);\n    });\n  }\n\n  private _getRenderElementWithArea(\n    graphicalElement: BaseElement,\n    rotation: number,\n    coachDimension: ElementDimension,\n  ): TemplateResult {\n    // TODO -> isNotTableGraphicTempFix is temp fix to show coach tables as area and not as svg graphic.\n    // The problem here is that when using TABLE svg graphics,\n    // they are displayed distorted due to different heights and widths and this is not visually good.\n    const isNotTableGraphicTempFix = graphicalElement.icon?.indexOf('TABLE') === -1;\n\n    const areaProperty =\n      graphicalElement.icon && isNotTableGraphicTempFix ? graphicalElement.icon : null;\n    const stretchHeight = areaProperty !== 'ENTRY_EXIT';\n    const ariaLabelForArea = graphicalElement.icon\n      ? getI18nSeatReservation(graphicalElement.icon, this._language.current)\n      : nothing;\n    const calculatedDimension = this.getCalculatedDimension(\n      graphicalElement.dimension,\n      coachDimension,\n      true,\n      stretchHeight,\n    );\n    const calculatedPosition = this.getCalculatedPosition(\n      graphicalElement.position,\n      graphicalElement.dimension,\n      coachDimension,\n      true,\n    );\n\n    let elementMounting = 'free';\n    if (graphicalElement.position.y === this.coachBorderOffset * -1) {\n      elementMounting = 'upper-border';\n    } else if (\n      graphicalElement.position.y + graphicalElement.dimension.h ===\n      coachDimension.h + this.coachBorderOffset\n    ) {\n      elementMounting = 'lower-border';\n    }\n\n    return html`\n      <sbb-seat-reservation-scoped\n        scoped-classes=\"graphical-element\"\n        inset-block-start=\"${calculatedPosition.y}px\"\n        inset-inline-start=\"${calculatedPosition.x}px\"\n        width=\"${calculatedDimension.w}px\"\n        height=\"${calculatedDimension.h}px\"\n        z-index=\"${graphicalElement.position.z}\"\n      >\n        <sbb-seat-reservation-area\n          style=${styleMap({\n            '--sbb-reservation-area-width': graphicalElement.dimension.w * this.baseGridSize,\n            '--sbb-reservation-area-height': graphicalElement.dimension.h * this.baseGridSize,\n          })}\n          mounting=${elementMounting}\n          background=\"dark\"\n          aria-hidden=\"true\"\n          title=${ariaLabelForArea}\n        >\n          ${areaProperty\n            ? html`\n                <sbb-seat-reservation-graphic\n                  name=${areaProperty}\n                  rotation=${rotation}\n                  width=${this.baseGridSize}\n                  height=${this.baseGridSize}\n                  role=\"img\"\n                  aria-hidden=\"true\"\n                ></sbb-seat-reservation-graphic>\n              `\n            : nothing}\n        </sbb-seat-reservation-area>\n      </sbb-seat-reservation-scoped>\n    `;\n  }\n\n  private _getRenderElementWithoutArea(\n    graphicalElement: BaseElement,\n    rotation: number,\n    coachDimension: ElementDimension,\n  ): TemplateResult {\n    const calculatedDimension = this.getCalculatedDimension(\n      graphicalElement.dimension,\n      coachDimension,\n    );\n    const calculatedPosition = this.getCalculatedPosition(\n      graphicalElement.position,\n      graphicalElement.dimension,\n      coachDimension,\n    );\n\n    // If the icon is the driver area, then here concat the vehicle type to get the right vehicle chassie icon\n    const icon =\n      graphicalElement.icon && graphicalElement.icon.indexOf('DRIVER_AREA') === -1\n        ? graphicalElement.icon\n        : graphicalElement.icon?.concat('_', this.seatReservation.vehicleType);\n\n    return html`\n      <sbb-seat-reservation-scoped\n        scoped-classes=\"graphical-element\"\n        inset-block-start=\"${calculatedPosition.y}px\"\n        inset-inline-start=\"${calculatedPosition.x}px\"\n        width=\"${calculatedDimension.w}px\"\n        height=\"${calculatedDimension.h}px\"\n        z-index=\"${graphicalElement.position.z}\"\n      >\n        <sbb-seat-reservation-graphic\n          name=${icon ?? nothing}\n          width=${graphicalElement.dimension.w * this.baseGridSize}\n          height=${graphicalElement.dimension.h * this.baseGridSize}\n          rotation=${rotation}\n          aria-hidden=\"true\"\n          ?stretch=${true}\n        ></sbb-seat-reservation-graphic>\n      </sbb-seat-reservation-scoped>\n    `;\n  }\n\n  private _getRenderedServiceElements(serviceElements?: BaseElement[]): TemplateResult[] | null {\n    if (!serviceElements) {\n      return null;\n    }\n\n    return serviceElements?.map((serviceElement: BaseElement) => {\n      const titleDescription = serviceElement.icon\n        ? getI18nSeatReservation(serviceElement.icon, this._language.current)\n        : null;\n      const calculatedcCmpartmentNumberDimension = this.getCalculatedDimension(\n        serviceElement.dimension,\n      );\n      const calculatedcCmpartmentNumberPosition = this.getCalculatedPosition(\n        serviceElement.position,\n      );\n      const elementRotation = serviceElement.rotation || 0;\n      const elementFixedRotation = this.alignVertical ? elementRotation - 90 : elementRotation;\n\n      return html`\n        <sbb-seat-reservation-scoped\n          scoped-classes=\"graphical-element\"\n          inset-block-start=\"${calculatedcCmpartmentNumberPosition.y}px\"\n          inset-inline-start=\"${calculatedcCmpartmentNumberPosition.x}px\"\n          width=\"${calculatedcCmpartmentNumberDimension.w}px\"\n          height=\"${calculatedcCmpartmentNumberDimension.h}px\"\n          z-index=\"${serviceElement.position.z}\"\n        >\n          <sbb-seat-reservation-graphic\n            name=${serviceElement.icon ?? nothing}\n            width=${serviceElement.dimension.w * this.baseGridSize}\n            height=${serviceElement.dimension.h * this.baseGridSize}\n            .rotation=${elementFixedRotation}\n            role=\"img\"\n            aria-hidden=\"true\"\n            title=${titleDescription ?? nothing}\n          ></sbb-seat-reservation-graphic>\n        </sbb-seat-reservation-scoped>\n      `;\n    });\n  }\n\n  /**\n   * Manages the selected place event triggered from the place\n   * Each selection emits an array of all selected places\n   * @param selectPlaceEvent\n   */\n  private _onSelectPlace(selectPlaceEvent: CustomEvent<PlaceSelection>): void {\n    const selectedPlace = selectPlaceEvent.detail;\n    // We have to set preventCoachScrollByPlaceClick to true, to prevent automatic scrolling to the new focused place\n    this.preventCoachScrollByPlaceClick = true;\n    this.isCoachGridFocusable = false;\n    if (!this.preventPlaceClick) {\n      // Add place to place collection\n      this.updateSelectedSeatReservationPlaces(selectedPlace);\n      this.updateCurrentSelectedPlaceInCoach(selectedPlace);\n    }\n  }\n\n  private _onSelectNavCoach(event: CustomEvent<number>): void {\n    const selectedNavCoachIndex = event.detail;\n    this.isKeyboardNavigation = false;\n\n    if (selectedNavCoachIndex !== null && selectedNavCoachIndex !== this.currSelectedCoachIndex) {\n      this.unfocusPlaceElement();\n      this.scrollToSelectedNavCoach(selectedNavCoachIndex);\n    } else if (selectedNavCoachIndex === this.currSelectedCoachIndex) {\n      this.updateCurrentSelectedCoach();\n      this.preselectPlaceInCoach();\n    }\n  }\n\n  private _onFocusNavCoach(): void {\n    if (!this.preventCoachScrollByPlaceClick) {\n      this.preselectPlaceInCoach();\n    } else {\n      this.focusPlaceElement(this.currSelectedPlace);\n    }\n    this.isAutoScrolling = false;\n  }\n\n  private _getDescriptionTableCoach(coachItem: CoachItem): string {\n    if (!coachItem.places?.length) {\n      return getI18nSeatReservation('COACH_BLOCKED_TABLE_CAPTION', this._language.current, [\n        coachItem.id,\n      ]);\n    }\n\n    let tableCoachDescription = '';\n    const areaDescriptions = this._getTitleDescriptionListString(coachItem.graphicElements!);\n    const serviceDescriptions = this._getTitleDescriptionListString(coachItem.serviceElements!);\n\n    tableCoachDescription = getI18nSeatReservation('COACH_TABLE_CAPTION', this._language.current, [\n      coachItem.id,\n    ]);\n\n    if (!!areaDescriptions || !!serviceDescriptions) {\n      tableCoachDescription +=\n        '. ' + getI18nSeatReservation('COACH_AVAILABLE_SERVICES', this._language.current) + ': ';\n      tableCoachDescription += serviceDescriptions + ', ' + areaDescriptions + '.';\n    }\n    return tableCoachDescription;\n  }\n\n  private _getTitleDescriptionListString(descriptionsElements: BaseElement[]): string {\n    const uniqueDescriptions: string[] = [];\n\n    return descriptionsElements\n      ?.map((descriptionElement) => {\n        const icon = descriptionElement.icon;\n        if (!icon) return null;\n\n        const descriptionAlreayExist = uniqueDescriptions.indexOf(icon) > -1;\n        const translation = getI18nSeatReservation(\n          descriptionElement.icon!,\n          this._language.current,\n        );\n        const isValidDescription =\n          this._notFixedRotatableAreaIcons.indexOf(icon) === -1 &&\n          this._notAreaElements.indexOf(icon) === -1;\n\n        if (!descriptionAlreayExist) {\n          uniqueDescriptions.push(descriptionElement.icon!);\n        }\n        return !!translation && !descriptionAlreayExist && isValidDescription ? translation : null;\n      })\n      .filter((description) => !!description)\n      .join(', ');\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-seat-reservation': SbbSeatReservationElement;\n  }\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"seat-reservation.component.js","sources":["../../../../../src/elements-experimental/seat-reservation/seat-reservation/seat-reservation.component.ts"],"sourcesContent":["import { SbbLanguageController } from '@sbb-esta/lyne-elements/core/controllers.js';\nimport { html, isServer, nothing } from 'lit';\nimport type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { customElement } from 'lit/decorators.js';\nimport { classMap } from 'lit/directives/class-map.js';\nimport { styleMap } from 'lit/directives/style-map.js';\n\nimport { getI18nSeatReservation } from '../common.js';\nimport type {\n  CoachItem,\n  Place,\n  ElementDimension,\n  BaseElement,\n  PlaceSelection,\n  SeatReservation,\n} from '../common.js';\n\nimport { SeatReservationBaseElement } from './seat-reservation-base-element.js';\nimport style from './seat-reservation.scss?lit&inline';\n\nimport '@sbb-esta/lyne-elements/button.js';\nimport '@sbb-esta/lyne-elements/screen-reader-only.js';\nimport '../seat-reservation-area.js';\nimport '../seat-reservation-graphic.js';\nimport '../seat-reservation-place-control.js';\nimport '../seat-reservation-navigation-coach.js';\nimport '../seat-reservation-scoped.js';\nimport '@sbb-esta/lyne-elements/popover/popover.js';\n\n/**\n * Main component for the seat reservation.\n *\n */\nexport\n@customElement('sbb-seat-reservation')\nclass SbbSeatReservationElement extends SeatReservationBaseElement {\n  public static override styles: CSSResultGroup = style;\n\n  private _language = new SbbLanguageController(this);\n  private _coachesHtmlTemplate?: TemplateResult;\n  // Graphics that should not be rendered with an area\n  private _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  // Area icons that should not be fixed during rotation when vertical mode is selected\n  private _notFixedRotatableAreaIcons = ['ENTRY_EXIT'];\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('hasNavigation')) {\n      if (this.hasNavigation) {\n        this.shadowRoot\n          ?.querySelectorAll('table')\n          .forEach((table) => table.removeAttribute('tabindex'));\n      } else {\n        this.shadowRoot\n          ?.querySelectorAll('table')\n          .forEach((table) => table.setAttribute('tabindex', '0'));\n      }\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    // We need to wait until the first update is complete to init different html element dimensions\n    this.updateComplete.then(() => {\n      this.initPrepairSeatReservationData();\n      this.initNavigationSelectionByScrollEvent();\n\n      // We have to initiate the render process manually so that the prepared data is applied directly\n      // and not only after an interaction with the component itself\n      this.requestUpdate();\n    });\n  }\n\n  protected override render(): TemplateResult | null {\n    if (!isServer) {\n      this._determineBaseFontSize();\n    }\n\n    this._initVehicleSeatReservationConstruction();\n    return this._coachesHtmlTemplate || null;\n  }\n\n  private _determineBaseFontSize(): void {\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  private _initVehicleSeatReservationConstruction(): void {\n    const classAlignVertical = this.alignVertical ? 'sbb-sr__grid--vertical' : '';\n    this._coachesHtmlTemplate = html`\n      <div class=\"sbb-sr__container\">\n        <div class=\"sbb-sr sbb-sr__grid ${classAlignVertical}\">\n          <div class=\"sbb-sr-navigation-first-grid\">\n            ${this._renderNavigationControlButton('DIRECTION_LEFT')}\n          </div>\n          <div\n            class=\"sbb-sr__component\"\n            @keydown=${(evt: KeyboardEvent) => this.handleKeyboardEvent(evt)}\n          >\n            <div class=\"sbb-sr-grid-inner\">\n              <div class=\"nav-grid\">${this._renderNavigation()}</div>\n              <div class=\"coaches-grid\">\n                <div class=\"sbb-sr__wrapper-coach-decks\">\n                  <div class=\"sbb-sr__wrapper-deck-labels\">${this._renderDeckLabels()}</div>\n                  <div id=\"sbb-sr__wrapper-scrollarea\" class=\"sbb-sr__wrapper\">\n                    <div id=\"sbb-sr__parent-area\" class=\"sbb-sr__parent\" tabindex=\"-1\">\n                      <ul\n                        class=\"${classMap({\n                          'sbb-sr__list-decks': true,\n                          'sbb-sr__list-decks--gap': this.hasMultipleDecks,\n                        })}\"\n                      >\n                        ${this.seatReservations?.map(\n                          (seatReservation: SeatReservation, index: number) => {\n                            return html`<li class=\"sbb-sr__list-item-deck\">\n                              <ul class=\"sbb-sr__list-coaches\" role=\"presentation\">\n                                ${this._renderCoaches(seatReservation, index)}\n                              </ul>\n                            </li>`;\n                          },\n                        )}\n                      </ul>\n                    </div>\n                  </div>\n                </div>\n              </div>\n            </div>\n          </div>\n          <div class=\"sbb-sr-navigation-last-grid\">\n            ${this._renderNavigationControlButton('DIRECTION_RIGHT')}\n          </div>\n        </div>\n      </div>\n    `;\n  }\n\n  private _renderDeckLabels(): TemplateResult[] | null {\n    if (!this.hasMultipleDecks) return null;\n\n    return this.seatReservations.map((seatReservation) => {\n      const deckDescription = getI18nSeatReservation(\n        seatReservation.deckCoachLevel,\n        this._language.current,\n      );\n      return html`<b aria-hidden=\"true\">${deckDescription}</b>`;\n    });\n  }\n\n  private _renderNavigationControlButton(btnDirection: string): TemplateResult | null {\n    if (!this.hasNavigation || !this.seatReservations) return null;\n\n    const btnId = btnDirection == 'DIRECTION_RIGHT' ? 'last-tab-element' : 'first-tab-element';\n    const btnIcon = btnDirection == 'DIRECTION_RIGHT' ? 'arrow-right-small' : 'arrow-left-small';\n    const btnAriaDescription =\n      btnDirection == 'DIRECTION_RIGHT'\n        ? getI18nSeatReservation('SEAT_RESERVATION_END', this._language.current)\n        : getI18nSeatReservation('SEAT_RESERVATION_BEGIN', this._language.current);\n    let btnDisabled = true;\n\n    if (btnDirection == 'DIRECTION_LEFT' && this.selectedCoachIndex > 0) {\n      btnDisabled = false;\n    } else if (\n      btnDirection == 'DIRECTION_RIGHT' &&\n      this.selectedCoachIndex <\n        this.seatReservations[this.currSelectedDeckIndex].coachItems.length - 1\n    ) {\n      btnDisabled = false;\n    }\n\n    return html`<sbb-secondary-button\n      @click=\"${() => this.navigateByDirectionBtn(btnDirection)}\"\n      id=\"${btnId}\"\n      class=\"sbb-sr__navigation-control-button\"\n      size=\"s\"\n      icon-name=\"${btnIcon}\"\n      type=\"button\"\n      aria-label=\"${btnAriaDescription}\"\n      role=\"contentinfo\"\n      .disabledInteractive=\"${btnDisabled || nothing}\"\n    ></sbb-secondary-button>`;\n  }\n\n  private _renderNavigation(): TemplateResult | null {\n    if (!this.hasNavigation || !this.seatReservations) return null;\n\n    return html`<div class=\"sbb-sr-navigation-wrapper\">\n      <nav id=\"sbb-sr-navigation\" class=\"sbb-sr-navigation\">\n        <ul\n          id=\"sbb-sr__navigation-list-coaches\"\n          class=\"sbb-sr-navigation__list-coaches\"\n          aria-label=\"${getI18nSeatReservation(\n            'SEAT_RESERVATION_NAVIGATION',\n            this._language.current,\n          )}\"\n        >\n          ${this.seatReservations[this.currSelectedDeckIndex]?.coachItems.map(\n            (coachItem: CoachItem, index: number) => {\n              const coachFreePlaces = this.getAvailableFreePlacesNumFromCoach(index);\n              return html`<li>\n                <sbb-seat-reservation-navigation-coach\n                  @selectcoach=${(event: CustomEvent<number>) => this._onSelectNavCoach(event)}\n                  @focuscoach=${() => this._onFocusNavCoach()}\n                  class=\"${classMap({\n                    'sbb-sr__navigation-coach--hover-scroll':\n                      this.hoveredScrollCoachIndex === index,\n                  })}\"\n                  index=\"${index}\"\n                  coach-id=\"${coachItem.id}\"\n                  .freePlacesByType=\"${coachFreePlaces}\"\n                  .selected=${this.selectedCoachIndex === index}\n                  .focused=${this.focusedCoachIndex === index}\n                  .propertyIds=\"${coachItem.propertyIds}\"\n                  .travelClass=\"${coachItem.travelClass}\"\n                  ?driver-area=\"${!coachItem.places?.length}\"\n                  ?first=\"${coachItem?.driverAreaSide?.left}\"\n                  ?last=\"${coachItem?.driverAreaSide?.right}\"\n                  ?vertical=\"${this.alignVertical}\"\n                >\n                </sbb-seat-reservation-navigation-coach>\n              </li>`;\n            },\n          )}\n        </ul>\n      </nav>\n    </div>`;\n  }\n  /**\n   *\n   * @param coaches\n   * @returns\n   */\n  private _renderCoaches(\n    seatReservation: SeatReservation,\n    deckIndex: number,\n  ): TemplateResult[] | null {\n    const coaches = JSON.parse(JSON.stringify(seatReservation?.coachItems));\n\n    if (!coaches) {\n      return null;\n    }\n    return coaches.map((coachItem: CoachItem, coachIndex: number) => {\n      return html`\n        <li class=\"sbb-sr__item-coach\">\n          ${this._renderCoachElement(coachItem, coachIndex, deckIndex)}\n        </li>\n      `;\n    });\n  }\n\n  private _renderCoachElement(\n    coachItem: CoachItem,\n    coachIndex: number,\n    coachDeckIndex: number,\n  ): TemplateResult {\n    const calculatedCoachDimension = this.getCalculatedDimension(coachItem.dimension);\n    const descriptionTableCoachWithServices = this._getDescriptionTableCoach(coachItem, coachIndex);\n\n    return html`<sbb-seat-reservation-scoped\n      style=${styleMap({\n        '--sbb-seat-reservation-scoped-width': calculatedCoachDimension.w,\n        '--sbb-seat-reservation-scoped-height': calculatedCoachDimension.h,\n      })}\n    >\n      ${this._getRenderedCoachBorders(coachItem)}\n      ${this._getRenderedGraphicalElements(\n        coachItem.graphicElements || [],\n        coachItem.dimension,\n        coachIndex,\n        coachDeckIndex,\n      )}\n      ${this._getRenderedServiceElements(coachIndex, coachDeckIndex, coachItem.serviceElements)}\n\n      <table\n        @focus=${() => this.onFocusTableCoachAndPreselectPlace(coachIndex)}\n        id=\"sbb-sr-coach-${coachIndex}\"\n        class=\"sbb-sr-coach-wrapper__table\"\n        aria-describedby=\"sbb-sr-coach-caption-${coachIndex}\"\n      >\n        <caption id=\"sbb-sr-coach-caption-${coachIndex}\" tabindex=\"-1\">\n          <sbb-screen-reader-only>${descriptionTableCoachWithServices}</sbb-screen-reader-only>\n        </caption>\n        ${this._getRenderedRowPlaces(coachItem, coachIndex, coachDeckIndex)}\n      </table>\n    </sbb-seat-reservation-scoped>`;\n  }\n\n  /**\n   * @returns Returns the border graphic (COACH_BORDER_MIDDLE) of a coach with calculated border gap and coach width,\n   * depending on whether the coach is with a driver area or without.\n   */\n  private _getRenderedCoachBorders(coachItem: CoachItem): TemplateResult {\n    const COACH_PASSAGE_WIDTH = 1;\n    const allElements = coachItem.graphicElements;\n    const driverArea = allElements?.find((element: BaseElement) => element.icon === 'DRIVER_AREA');\n    const borderWidth = driverArea\n      ? coachItem.dimension.w - driverArea.dimension.w - COACH_PASSAGE_WIDTH\n      : coachItem.dimension.w - COACH_PASSAGE_WIDTH * 2;\n    const borderHeight = (coachItem.dimension.h + this.coachBorderOffset * 2) * this.baseGridSize;\n    const borderOffsetX =\n      driverArea && driverArea.position.x === 0\n        ? driverArea?.dimension.w * this.baseGridSize\n        : this.baseGridSize;\n    return html`\n      <sbb-seat-reservation-graphic\n        style=${styleMap({\n          '--sbb-seat-reservation-graphic-width': borderWidth * this.baseGridSize,\n          '--sbb-seat-reservation-graphic-height': borderHeight,\n          '--sbb-seat-reservation-graphic-top': this.coachBorderPadding * -1,\n          '--sbb-seat-reservation-graphic-left': borderOffsetX,\n          '--sbb-seat-reservation-graphic-position': 'absolute',\n        })}\n        name=\"COACH_BORDER_MIDDLE\"\n        ?stretch=${true}\n        role=\"presentation\"\n      ></sbb-seat-reservation-graphic>\n    `;\n  }\n\n  private _getRenderedRowPlaces(\n    coach: CoachItem,\n    coachIndex: number,\n    deckIndex: number,\n  ): TemplateResult[] | null {\n    if (!coach.places) {\n      return null;\n    }\n\n    // Prepair rows with the places to render a table\n    const tableRowPlaces: Record<number, Place[]> = {};\n    for (const place of coach.places) {\n      if (!tableRowPlaces[place.position.y]) {\n        tableRowPlaces[place.position.y] = [place];\n      } else {\n        tableRowPlaces[place.position.y].push(place);\n      }\n    }\n\n    return Object.values(tableRowPlaces)\n      .map((rowPlaces: Place[], index) => {\n        return html`\n          <tr id=\"row-${coachIndex}-${rowPlaces[0].position.y}\" data-row-index=${index}>\n            ${this._getRenderedColumnPlaces(rowPlaces, coachIndex, deckIndex)}\n          </tr>\n        `;\n      })\n      .flatMap((rowTemplate) => rowTemplate);\n  }\n\n  private _getRenderedColumnPlaces(\n    places: Place[],\n    coachIndex: number,\n    deckIndex: number,\n  ): TemplateResult[] | null {\n    //Sorts each place by its ascending x coordinate\n    places.sort(\n      (placeA: Place, placeB: Place) => Number(placeA.position.x) - Number(placeB.position.x),\n    );\n\n    return places?.map((place: Place, index: number) => {\n      const calculatedDimension = this.getCalculatedDimension(place.dimension);\n      const calculatedPosition = this.getCalculatedPosition(place.position);\n      const textRotation = this.alignVertical ? -90 : 0;\n\n      return html`\n        <td\n          id=\"cell-${deckIndex}-${coachIndex}-${place.position.y}-${index}\"\n          class=\"graphical-element\"\n        >\n          <sbb-seat-reservation-place-control\n            style=${styleMap({\n              '--sbb-seat-reservation-place-control-width': calculatedDimension.w,\n              '--sbb-seat-reservation-place-control-height': calculatedDimension.h,\n              '--sbb-seat-reservation-place-control-top': calculatedPosition.y,\n              '--sbb-seat-reservation-place-control-left': calculatedPosition.x,\n            })}\n            @selectplace=${(selectPlaceEvent: CustomEvent<PlaceSelection>) =>\n              this._onSelectPlace(selectPlaceEvent)}\n            exportparts=\"sbb-sr-place-part\"\n            id=\"seat-reservation__place-button-${deckIndex}-${coachIndex}-${place.number}\"\n            class=\"seat-reservation-place-control\"\n            data-cell-id=\"${coachIndex}-${place.position.y}-${index}\"\n            text=${place.number}\n            type=${place.type}\n            state=${place.state}\n            width=${place.dimension.w * this.baseGridSize}\n            height=${place.dimension.h * this.baseGridSize}\n            rotation=${place.rotation ?? nothing}\n            text-rotation=${textRotation}\n            coach-index=${coachIndex}\n            deck-index=${deckIndex}\n            .propertyIds=${place.propertyIds}\n            .preventClick=${this.preventPlaceClick}\n          ></sbb-seat-reservation-place-control>\n        </td>\n      `;\n    });\n  }\n\n  private _getRenderedGraphicalElements(\n    graphicalElements: BaseElement[],\n    coachDimension: ElementDimension,\n    coachIndex: number,\n    coachDeckIndex: number,\n  ): TemplateResult[] | null {\n    if (!graphicalElements) return null;\n\n    return graphicalElements?.map((graphicalElement: BaseElement) => {\n      const icon = graphicalElement.icon ?? '';\n      const elementRotation = graphicalElement.rotation || 0;\n      const isNotFixedRotationGraphicalElement =\n        this._notFixedRotatableAreaIcons.indexOf(graphicalElement.icon!) === -1;\n      const elementFixedRotation =\n        this.alignVertical && isNotFixedRotationGraphicalElement\n          ? elementRotation - 90\n          : elementRotation;\n\n      //check if the current element is not an area element, since this element is drawn without an area component\n      if (this._notAreaElements.findIndex((notAreaElement) => notAreaElement === icon) > -1) {\n        return this._getRenderElementWithoutArea(graphicalElement, elementRotation, coachDimension);\n      }\n      return this._getRenderElementWithArea(\n        graphicalElement,\n        elementFixedRotation,\n        coachDimension,\n        coachIndex,\n        coachDeckIndex,\n      );\n    });\n  }\n\n  /**\n   * creates a rendered element with an area component\n   * @param graphicalElement\n   * @param rotation\n   * @param coachDimension\n   * @param coachIndex used to generate a unique id for the popover trigger\n   * @private\n   */\n  private _getRenderElementWithArea(\n    graphicalElement: BaseElement,\n    rotation: number,\n    coachDimension: ElementDimension,\n    coachIndex: number,\n    coachDeckIndex: number,\n  ): TemplateResult {\n    // for TABLE, we use the area component itself to display the table instead of the SVG graphic.\n    // Due to different heights and widths, it wouldn't show correctly. To correct this, we would\n    // need difficult calculations for position, rotation and dimension.\n    const isNotTableGraphic = graphicalElement.icon?.indexOf('TABLE') === -1;\n    const areaProperty = graphicalElement.icon && isNotTableGraphic ? graphicalElement.icon : null;\n    const stretchHeight = areaProperty !== 'ENTRY_EXIT';\n    const ariaLabelForArea = graphicalElement.icon\n      ? getI18nSeatReservation(graphicalElement.icon, this._language.current)\n      : nothing;\n    const calculatedDimension = this.getCalculatedDimension(\n      graphicalElement.dimension,\n      coachDimension,\n      true,\n      stretchHeight,\n    );\n    const calculatedPosition = this.getCalculatedPosition(\n      graphicalElement.position,\n      graphicalElement.dimension,\n      coachDimension,\n      true,\n    );\n\n    //generate unique index number for the trigger element\n    const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;\n    let elementMounting = 'free';\n\n    if (graphicalElement.position.y === this.coachBorderOffset * -1) {\n      elementMounting = 'upper-border';\n    } else if (\n      graphicalElement.position.y + graphicalElement.dimension.h ===\n      coachDimension.h + this.coachBorderOffset\n    ) {\n      elementMounting = 'lower-border';\n    }\n\n    return html`\n      <sbb-seat-reservation-area\n        id=\"${triggerId}\"\n        class=\"${classMap({ 'sbb-seat-reservation-area--cursor-pointer': areaProperty !== null })}\"\n        style=${styleMap({\n          '--sbb-seat-reservation-area-width': calculatedDimension.w,\n          '--sbb-seat-reservation-area-height': calculatedDimension.h,\n          '--sbb-seat-reservation-area-top': calculatedPosition.y,\n          '--sbb-seat-reservation-area-left': calculatedPosition.x,\n        })}\n        mounting=${elementMounting}\n        background=\"dark\"\n        aria-hidden=\"true\"\n      >\n        ${areaProperty\n          ? html`\n              <sbb-seat-reservation-graphic\n                name=${areaProperty}\n                width=${this.baseGridSize}\n                height=${this.baseGridSize}\n                rotation=${rotation}\n                role=\"img\"\n                aria-hidden=\"true\"\n              ></sbb-seat-reservation-graphic>\n            `\n          : nothing}\n      </sbb-seat-reservation-area>\n      ${areaProperty ? this._popover(triggerId, ariaLabelForArea) : nothing}\n    `;\n  }\n\n  private _getRenderElementWithoutArea(\n    graphicalElement: BaseElement,\n    rotation: number,\n    coachDimension: ElementDimension,\n  ): TemplateResult {\n    const calculatedDimension = this.getCalculatedDimension(\n      graphicalElement.dimension,\n      coachDimension,\n    );\n    const calculatedPosition = this.getCalculatedPosition(\n      graphicalElement.position,\n      graphicalElement.dimension,\n      coachDimension,\n    );\n\n    // If the icon is the driver area, then here concat the vehicle type to get the right vehicle chassie icon\n    const icon =\n      graphicalElement.icon && graphicalElement.icon.indexOf('DRIVER_AREA') === -1\n        ? graphicalElement.icon\n        : graphicalElement.icon?.concat(\n            '_',\n            this.seatReservations[this.currSelectedDeckIndex].vehicleType,\n          );\n\n    return html` <sbb-seat-reservation-graphic\n      style=${styleMap({\n        '--sbb-seat-reservation-graphic-width': calculatedDimension.w,\n        '--sbb-seat-reservation-graphic-height': calculatedDimension.h,\n        '--sbb-seat-reservation-graphic-top': calculatedPosition.y,\n        '--sbb-seat-reservation-graphic-left': calculatedPosition.x,\n        '--sbb-seat-reservation-graphic-position': 'absolute',\n      })}\n      name=${icon ?? nothing}\n      rotation=${rotation}\n      aria-hidden=\"true\"\n      ?stretch=${true}\n    ></sbb-seat-reservation-graphic>`;\n  }\n\n  private _getRenderedServiceElements(\n    coachIndex: number,\n    coachDeckIndex: number,\n    serviceElements?: BaseElement[],\n  ): TemplateResult[] | null {\n    if (!serviceElements) return null;\n\n    return serviceElements?.map((serviceElement: BaseElement) => {\n      const titleDescription = serviceElement.icon\n        ? getI18nSeatReservation(serviceElement.icon, this._language.current)\n        : null;\n      const calculatedDimension = this.getCalculatedDimension(serviceElement.dimension);\n      const calculatedPosition = this.getCalculatedPosition(serviceElement.position);\n      const elementRotation = serviceElement.rotation || 0;\n      const elementFixedRotation = this.alignVertical ? elementRotation - 90 : elementRotation;\n\n      //generate unique index number for the trigger element\n      const triggerId = `popover-trigger-${coachDeckIndex}-${coachIndex}-${calculatedPosition.x}-${calculatedPosition.y}`;\n\n      return html`\n        <sbb-seat-reservation-graphic\n          id=\"${triggerId}\"\n          style=${styleMap({\n            '--sbb-seat-reservation-graphic-width': calculatedDimension.w,\n            '--sbb-seat-reservation-graphic-height': calculatedDimension.h,\n            '--sbb-seat-reservation-graphic-top': calculatedPosition.y,\n            '--sbb-seat-reservation-graphic-left': calculatedPosition.x,\n            '--sbb-seat-reservation-graphic-position': 'absolute',\n          })}\n          class=\"sbb-seat-reservation-graphic--cursor-pointer\"\n          name=${serviceElement.icon ?? nothing}\n          .rotation=${elementFixedRotation}\n          role=\"img\"\n          aria-hidden=\"true\"\n        ></sbb-seat-reservation-graphic>\n        ${this._popover(triggerId, titleDescription)}\n      `;\n    });\n  }\n\n  /**\n   * Manages the selected place event triggered from the place\n   * Each selection emits an array of all selected places\n   * @param selectPlaceEvent\n   */\n  private _onSelectPlace(selectPlaceEvent: CustomEvent<PlaceSelection>): void {\n    const selectedPlace = selectPlaceEvent.detail;\n    // We have to set preventCoachScrollByPlaceClick to true, to prevent automatic scrolling to the new focused place\n    this.preventCoachScrollByPlaceClick = true;\n    this.isCoachGridFocusable = false;\n    if (!this.preventPlaceClick) {\n      // Set current deck index if a places was selected\n      this.currSelectedDeckIndex = selectedPlace.deckIndex;\n      // Add place to place collection\n      this.updateSelectedSeatReservationPlaces(selectedPlace);\n      this.updateCurrentSelectedPlaceInCoach(selectedPlace);\n    }\n  }\n\n  private _onSelectNavCoach(event: CustomEvent<number>): void {\n    const selectedNavCoachIndex = event.detail;\n    this.isKeyboardNavigation = false;\n\n    if (selectedNavCoachIndex !== null && selectedNavCoachIndex !== this.currSelectedCoachIndex) {\n      this.unfocusPlaceElement();\n      this.scrollToSelectedNavCoach(selectedNavCoachIndex);\n    } else if (selectedNavCoachIndex === this.currSelectedCoachIndex) {\n      this.updateCurrentSelectedCoach();\n      this.preselectPlaceInCoach();\n    }\n\n    //close all opened popovers\n    this._closePopover();\n  }\n\n  private _onFocusNavCoach(): void {\n    if (!this.preventCoachScrollByPlaceClick) {\n      this.preselectPlaceInCoach();\n    } else {\n      this.focusPlaceElement(this.currSelectedPlace);\n    }\n    this.isAutoScrolling = false;\n  }\n\n  /**\n   * Creates a popover for extra service information\n   * @param triggerId\n   * @param popoverContent\n   * @private\n   */\n  private _popover(\n    triggerId: string,\n    popoverContent: string | null | typeof nothing,\n  ): TemplateResult {\n    return html`\n      <sbb-popover trigger=\"${triggerId}\">\n        <p class=\"sbb-text-s sbb-sr-popover\">${popoverContent}</p>\n      </sbb-popover>\n    `;\n  }\n\n  /**\n   * trigger to close all opened popovers (normally only one is opened at a time)\n   * @private\n   */\n  private _closePopover(): void {\n    this.shadowRoot\n      ?.querySelectorAll('sbb-popover[data-state=\"opened\"]')\n      .forEach((popover) => popover.setAttribute('data-state', 'closed'));\n  }\n\n  private _getDescriptionTableCoach(coachItem: CoachItem, coachIndex: number): string {\n    if (!coachItem.places?.length) {\n      return getI18nSeatReservation('COACH_BLOCKED_TABLE_CAPTION', this._language.current, [\n        coachItem.id,\n      ]);\n    }\n\n    let tableCoachDescription: string;\n    const areaDescriptions = this._getTitleDescriptionListString(coachItem.graphicElements!);\n    const serviceDescriptions = this._getTitleDescriptionListString(coachItem.serviceElements!);\n\n    tableCoachDescription = getI18nSeatReservation('COACH_TABLE_CAPTION', this._language.current, [\n      coachItem.id,\n    ]);\n\n    if (!this.hasNavigation) {\n      // Expands the number of available seats and bicycle spaces as info\n      const freePlaces = this.getAvailableFreePlacesNumFromCoach(coachIndex);\n      const freePlacesTxt = getI18nSeatReservation(\n        'COACH_AVAILABLE_NUMBER_OF_PLACES',\n        this._language.current,\n        [freePlaces.seats, freePlaces.bicycles],\n      );\n      tableCoachDescription = tableCoachDescription.concat('. ').concat(freePlacesTxt).concat('. ');\n    }\n\n    if (!!areaDescriptions || !!serviceDescriptions) {\n      tableCoachDescription +=\n        '. ' + getI18nSeatReservation('COACH_AVAILABLE_SERVICES', this._language.current) + ': ';\n      tableCoachDescription += serviceDescriptions + ', ' + areaDescriptions + '.';\n    }\n    return tableCoachDescription;\n  }\n\n  private _getTitleDescriptionListString(descriptionsElements: BaseElement[]): string {\n    const uniqueDescriptions: string[] = [];\n\n    return descriptionsElements\n      ?.map((descriptionElement) => {\n        const icon = descriptionElement.icon;\n        if (!icon) return null;\n\n        const descriptionAlreayExist = uniqueDescriptions.indexOf(icon) > -1;\n        const translation = getI18nSeatReservation(\n          descriptionElement.icon!,\n          this._language.current,\n        );\n        const isValidDescription =\n          this._notFixedRotatableAreaIcons.indexOf(icon) === -1 &&\n          this._notAreaElements.indexOf(icon) === -1;\n\n        if (!descriptionAlreayExist) {\n          uniqueDescriptions.push(descriptionElement.icon!);\n        }\n        return !!translation && !descriptionAlreayExist && isValidDescription ? translation : null;\n      })\n      .filter((description) => !!description)\n      .join(', ');\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-seat-reservation': SbbSeatReservationElement;\n  }\n}\n"],"names":[],"mappings":"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"}