@sbb-esta/lyne-elements-experimental 2.10.1 → 2.11.1

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

@@ -0,0 +1,615 @@
+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 { 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 { 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/screen-reader-only.js";
+import "../seat-reservation-area.js";
+import "../seat-reservation-graphic.js";
+import "../seat-reservation-place-control.js";
+import "../seat-reservation-navigation/seat-reservation-navigation-coach.js";
+import "./seat-reservation-scoped/seat-reservation-scoped.component.js";
+const style = css`*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-seat-reservation-grid-size: 16px;
+  --sbb-seat-reservation-vertical-offset: 0;
+  display: block;
+}
+:host ::part(coach-floor) {
+  fill: var(--sbb-color-white);
+}
+@media (forced-colors: active) {
+  :host ::part(coach-floor) {
+    fill: transparent;
+  }
+}
+
+.sbb-sr__wrapper--vertical {
+  width: fit-content;
+  position: relative;
+  inset-inline-start: var(--sbb-seat-reservation-vertical-offset);
+  rotate: 90deg;
+  transform-origin: top left;
+}
+
+.sbb-sr__wrapper--vertical .sbb-sr__parent {
+  overflow-y: hidden;
+}
+
+.sbb-sr__wrapper--vertical .sbb-sr__list-coaches {
+  width: 100vw;
+}
+
+.sbb-sr-navigation--vertical {
+  inset-inline-start: var(--sbb-seat-reservation-vertical-offset);
+  margin-inline-start: 1.25rem;
+  position: absolute;
+}
+.sbb-sr-navigation--vertical .sbb-sr-navigation__list-coaches {
+  flex-direction: column;
+}
+
+.sbb-sr-navigation__list-coaches {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  justify-content: center;
+  flex-wrap: nowrap;
+  gap: var(--sbb-spacing-fixed-1x);
+  min-height: 3.75rem;
+}
+
+.sbb-sr__parent {
+  overflow-x: scroll;
+  padding: 3rem 0;
+}
+
+.sbb-sr__list-coaches {
+  display: flex;
+  gap: 0.25rem;
+  padding: 0;
+  margin: 0;
+  list-style: none;
+}
+
+.sbb-sr__item-coach {
+  padding: 0;
+  margin: 0;
+  position: relative;
+}
+
+.sbb-sr-coach-wrapper__table {
+  outline: 0;
+}`;
+let SbbSeatReservationElement = (() => {
+  var _seatReservation_accessor_storage, _hasNavigation_accessor_storage, _alignVertical_accessor_storage, _maxReservations_accessor_storage, _preventPlaceClick_accessor_storage, _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._notAreaElements = [
+        "DRIVER_AREA_FULL",
+        "COACH_PASSAGE",
+        "COACH_WALL_NO_PASSAGE",
+        "COMPARTMENT_PASSAGE",
+        "COMPARTMENT_PASSAGE_HIGH",
+        "COMPARTMENT_PASSAGE_MIDDLE",
+        "COMPARTMENT_PASSAGE_LOW"
+      ];
+      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) {
+      var _a2, _b;
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("hasNavigation")) {
+        if (this.hasNavigation) {
+          (_a2 = this.shadowRoot) == null ? void 0 : _a2.querySelectorAll("table").forEach((table) => table.removeAttribute("tabindex"));
+        } else {
+          (_b = this.shadowRoot) == null ? void 0 : _b.querySelectorAll("table").forEach((table) => table.setAttribute("tabindex", "0"));
+        }
+      }
+    }
+    firstUpdated(changedProperties) {
+      super.firstUpdated(changedProperties);
+      this._componentSetup();
+    }
+    render() {
+      this._initVehicleSeatReservationConstruction();
+      return this._coachesHtmlTemplate || null;
+    }
+    _componentSetup() {
+      this.initNavigationSelectionByScrollEvent();
+    }
+    _initVehicleSeatReservationConstruction() {
+      var _a2;
+      const coachItems = JSON.parse(JSON.stringify((_a2 = this.seatReservation) == null ? void 0 : _a2.coachItems));
+      const classAlignVertical = this.alignVertical ? "sbb-sr__wrapper--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>
+          </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() {
+      var _a2;
+      if (!this.hasNavigation) {
+        return null;
+      }
+      return html`
+      <nav class="${classMap({ "sbb-sr-navigation--vertical": this.alignVertical })}">
+        <ul
+          class="sbb-sr-navigation__list-coaches"
+          aria-label="${getI18nSeatReservation("SEAT_RESERVATION_NAVIGATION", this._language.current)}"
+        >
+          ${(_a2 = this.seatReservation) == null ? void 0 : _a2.coachItems.map((coachItem, index) => {
+        var _a3, _b;
+        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="${!((_a3 = coachItem.places) == null ? void 0 : _a3.length)}"
+                ?first="${index === 0}"
+                ?last="${index === ((_b = this.seatReservation) == null ? void 0 : _b.coachItems.length) - 1}"
+                ?vertical="${this.alignVertical}"
+              >
+              </sbb-seat-reservation-navigation-coach>
+            </li>`;
+      })}
+        </ul>
+      </nav>
+    `;
+    }
+    /**
+     *
+     * @param coaches
+     * @returns
+     */
+    _renderCoaches(coaches) {
+      if (!coaches) {
+        return null;
+      }
+      return coaches.map((coachItem, index) => {
+        return html`
+        <li class="sbb-sr__item-coach">${this._renderCoachElement(coachItem, index)}</li>
+      `;
+      });
+    }
+    _renderCoachElement(coachItem, index) {
+      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"
+    >
+      ${this._getRenderedCoachBorders(coachItem, index)}
+      ${this._getRenderedGraphicalElements(coachItem.graphicElements || [], coachItem.dimension)}
+      ${this._getRenderedServiceElements(coachItem.serviceElements)}
+      <table
+        @focus=${() => this.onFocusTableCoachAndPreselectPlace(index)}
+        id="sbb-sr-coach-${index}"
+        class="sbb-sr-coach-wrapper__table"
+        aria-describedby="sbb-sr-coach-caption-${index}"
+      >
+        <caption id="sbb-sr-coach-caption-${index}" tabindex="-1">
+          <sbb-screen-reader-only>${descriptionTableCoachWithServices}</sbb-screen-reader-only>
+        </caption>
+        ${this._getRenderedRowPlaces(coachItem, index)}
+      </table>
+    </sbb-seat-reservation-scoped>`;
+    }
+    _getRenderedCoachBorders(coachItem, coachIndex) {
+      const allElements = coachItem.graphicElements;
+      const COACH_PASSAGE_WIDTH = 1;
+      const driverArea = allElements == null ? void 0 : allElements.find((element) => element.icon === "DRIVER_AREA_FULL");
+      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 == null ? void 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>
+    `;
+    }
+    _getRenderedRowPlaces(coach, coachIndex) {
+      if (!coach.places) {
+        return null;
+      }
+      const tableRowPlaces = {};
+      for (const place of coach.places) {
+        if (!tableRowPlaces[place.position.y]) {
+          tableRowPlaces[place.position.y] = [place];
+        } else {
+          tableRowPlaces[place.position.y].push(place);
+        }
+      }
+      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)}
+          </tr>
+        `;
+      }).flatMap((rowTemplate) => rowTemplate);
+    }
+    _getRenderedColumnPlaces(places, coachIndex) {
+      places.sort((placeA, placeB) => Number(placeA.position.x) - Number(placeB.position.x));
+      return places == null ? void 0 : places.map((place, index) => {
+        const calculatedInternalDimension = this.getCalculatedDimension(place.dimension);
+        const calculatedInternalPosition = 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}"
+        >
+          <sbb-seat-reservation-place-control
+            @selectPlace=${(selectPlaceEvent) => this._onSelectPlace(selectPlaceEvent)}
+            exportparts="sbb-sr-place-part"
+            id="seat-reservation__place-button-${coachIndex}-${place.number}"
+            class="seat-reservation-place-control"
+            data-cell-id="${coachIndex}-${place.position.y}-${index}"
+            text=${place.number}
+            type=${place.type}
+            state=${place.state}
+            width=${place.dimension.w * this.baseGridSize}
+            height=${place.dimension.h * this.baseGridSize}
+            rotation=${place.rotation ?? nothing}
+            text-rotation=${textRotation}
+            coach-index=${coachIndex}
+            .propertyIds=${place.propertyIds}
+            .preventClick=${this.preventPlaceClick}
+          ></sbb-seat-reservation-place-control>
+        </sbb-seat-reservation-scoped>
+      `;
+      });
+    }
+    _getRenderedGraphicalElements(graphicalElements, coachDimension) {
+      if (!graphicalElements) {
+        return null;
+      }
+      return graphicalElements == null ? void 0 : graphicalElements.map((graphicalElement) => {
+        const icon = graphicalElement.icon ?? "";
+        const elementRotation = graphicalElement.rotation || 0;
+        const isNotFixedRotationGraphicalElement = this._notFixedRotatableAreaIcons.indexOf(graphicalElement.icon) === -1;
+        const elementFixedRotation = this.alignVertical && isNotFixedRotationGraphicalElement ? elementRotation - 90 : elementRotation;
+        if (this._notAreaElements.findIndex((notAreaElement) => notAreaElement === icon) > -1) {
+          return this._getRenderElementWithoutArea(graphicalElement, elementRotation, coachDimension);
+        }
+        return this._getRenderElementWithArea(graphicalElement, elementFixedRotation, coachDimension);
+      });
+    }
+    _getRenderElementWithArea(graphicalElement, rotation, coachDimension) {
+      var _a2;
+      const isNotTableGraphicTempFix = ((_a2 = graphicalElement.icon) == null ? void 0 : _a2.indexOf("TABLE")) === -1;
+      const areaProperty = graphicalElement.icon && isNotTableGraphicTempFix ? 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);
+      let elementMounting = "free";
+      if (graphicalElement.position.y === this.coachBorderOffset * -1) {
+        elementMounting = "upper-border";
+      } else if (graphicalElement.position.y + graphicalElement.dimension.h === coachDimension.h + this.coachBorderOffset) {
+        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
+      })}
+          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>
+    `;
+    }
+    _getRenderElementWithoutArea(graphicalElement, rotation, coachDimension) {
+      var _a2;
+      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 : (_a2 = graphicalElement.icon) == null ? void 0 : _a2.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>
+    `;
+    }
+    _getRenderedServiceElements(serviceElements) {
+      if (!serviceElements) {
+        return null;
+      }
+      return serviceElements == null ? void 0 : 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 elementRotation = serviceElement.rotation || 0;
+        const elementFixedRotation = this.alignVertical ? elementRotation - 90 : elementRotation;
+        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>
+      `;
+      });
+    }
+    /**
+     * Manages the selected place event triggered from the place
+     * Each selection emits an array of all selected places
+     * @param selectPlaceEvent
+     */
+    _onSelectPlace(selectPlaceEvent) {
+      const selectedPlace = selectPlaceEvent.detail;
+      this.preventCoachScrollByPlaceClick = true;
+      this.isCoachGridFocusable = false;
+      if (!this.preventPlaceClick) {
+        this.updateSelectedSeatReservationPlaces(selectedPlace);
+        this.updateCurrentSelectedPlaceInCoach(selectedPlace);
+      }
+    }
+    _onSelectNavCoach(event) {
+      const selectedNavCoachIndex = event.detail;
+      this.isKeyboardNavigation = false;
+      if (selectedNavCoachIndex !== null && selectedNavCoachIndex !== this.currSelectedCoachIndex) {
+        this.unfocusPlaceElement();
+        this.scrollToSelectedNavCoach(selectedNavCoachIndex);
+      } else if (selectedNavCoachIndex === this.currSelectedCoachIndex) {
+        this.updateCurrentSelectedCoach();
+        this.preselectPlaceInCoach();
+      }
+    }
+    _onFocusNavCoach() {
+      if (!this.preventCoachScrollByPlaceClick) {
+        this.preselectPlaceInCoach();
+      } else {
+        this.focusPlaceElement(this.currSelectedPlace);
+      }
+      this.isAutoScrolling = false;
+    }
+    _getDescriptionTableCoach(coachItem) {
+      var _a2;
+      if (!((_a2 = coachItem.places) == null ? void 0 : _a2.length)) {
+        return getI18nSeatReservation("COACH_BLOCKED_TABLE_CAPTION", this._language.current, [
+          coachItem.id
+        ]);
+      }
+      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 (!!areaDescriptions || !!serviceDescriptions) {
+        tableCoachDescription += ". " + getI18nSeatReservation("COACH_AVAILABLE_SERVICES", this._language.current) + ": ";
+        tableCoachDescription += serviceDescriptions + ", " + areaDescriptions + ".";
+      }
+      return tableCoachDescription;
+    }
+    _getTitleDescriptionListString(descriptionsElements) {
+      const uniqueDescriptions = [];
+      return descriptionsElements == null ? void 0 : descriptionsElements.map((descriptionElement) => {
+        const icon = descriptionElement.icon;
+        if (!icon)
+          return null;
+        const descriptionAlreayExist = uniqueDescriptions.indexOf(icon) > -1;
+        const translation = getI18nSeatReservation(descriptionElement.icon, this._language.current);
+        const isValidDescription = this._notFixedRotatableAreaIcons.indexOf(icon) === -1 && this._notAreaElements.indexOf(icon) === -1;
+        if (!descriptionAlreayExist) {
+          uniqueDescriptions.push(descriptionElement.icon);
+        }
+        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, (() => {
+    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 });
+  })(), _a.styles = style, __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+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/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 *\n * @event {CustomEvent<SeatReservationSelectedPlacesEventDetails>} selectedPlaces - Emits when a place was selected and returns a Place array with all selected places\n * @event {CustomEvent<SeatReservationCoachSelection>} selectedCoach - Emits when a coach was selected and returns a CoachSelection\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) => 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) => 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): void {\n    const selectedPlace = selectPlaceEvent.detail as PlaceSelection;\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): void {\n    const selectedNavCoachIndex = event.detail as number;\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":["_a"],"mappings":"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"}