@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/time-input.js

@@ -0,0 +1,270 @@
+import { css, LitElement, html } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { ref } from "lit/directives/ref.js";
+import { SbbLanguageController } from "./core/controllers.js";
+import { findInput } from "./core/dom.js";
+import { EventEmitter, forwardEventToHost } from "./core/eventing.js";
+import { i18nTimeInputChange } from "./core/i18n.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+:host {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+  display: block;
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+const REGEX_ALLOWED_CHARACTERS = /[0-9.:,\-;_hH]/;
+const REGEX_GROUPS_WITHOUT_COLON = /^([0-9]{1,2})([0-9]{2})$/;
+const REGEX_GROUPS_WITH_COLON = /^([0-9]{1,2})?[.:,\-;_hH]?([0-9]{1,2})?$/;
+let SbbTimeInputElement = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this._input = null;
+    this._inputElement = null;
+    this._didChange = new EventEmitter(this, SbbTimeInputElement.events.didChange, {
+      bubbles: true,
+      cancelable: true
+    });
+    this._validationChange = new EventEmitter(
+      this,
+      SbbTimeInputElement.events.validationChange,
+      {
+        bubbles: true,
+        composed: false
+      }
+    );
+    this._abortController = new AbortController();
+    this._language = new SbbLanguageController(this);
+  }
+  set input(value) {
+    this._input = value;
+    this._findInputElement();
+  }
+  get input() {
+    return this._input;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this._findInputElement();
+    if (this._inputElement) {
+      this._updateValue(this._inputElement.value);
+    }
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = this._abortController) == null ? void 0 : _a.abort();
+  }
+  /** Gets the input value with the correct date format. */
+  // TODO: refactor this to be a get/set
+  getValueAsDate() {
+    var _a;
+    return this._formatValueAsDate(this._parseInput((_a = this._inputElement) == null ? void 0 : _a.value));
+  }
+  /** Set the input value to the correctly formatted value. */
+  setValueAsDate(date) {
+    if (!date || !this._inputElement) {
+      return;
+    }
+    const dateObj = date instanceof Date ? date : new Date(date);
+    this._inputElement.value = this._formatValue({
+      hours: dateObj.getHours(),
+      minutes: dateObj.getMinutes()
+    });
+    this._inputElement.dispatchEvent(new FocusEvent("blur", { composed: true }));
+  }
+  _findInputElement() {
+    const oldInput = this._inputElement;
+    this._inputElement = findInput(this, this.input);
+    if (oldInput !== this._inputElement) {
+      this._registerInputElement();
+    }
+  }
+  _registerInputElement() {
+    var _a;
+    (_a = this._abortController) == null ? void 0 : _a.abort();
+    if (!this._inputElement) {
+      return;
+    }
+    this._abortController = new AbortController();
+    this._inputElement.toggleAttribute("data-sbb-time-input", true);
+    this._inputElement.type = "text";
+    this._inputElement.inputMode = "numeric";
+    this._inputElement.maxLength = 5;
+    if (!this._inputElement.placeholder) {
+      this._inputElement.placeholder = "HH:MM";
+    }
+    this._inputElement.addEventListener(
+      "input",
+      (event) => forwardEventToHost(event, this),
+      { signal: this._abortController.signal }
+    );
+    this._inputElement.addEventListener(
+      "keydown",
+      (event) => this._preventCharInsert(event),
+      { signal: this._abortController.signal }
+    );
+    this._inputElement.addEventListener(
+      "change",
+      (event) => this._updateValueAndEmitChange(event),
+      {
+        signal: this._abortController.signal
+      }
+    );
+  }
+  /** Applies the correct format to values and triggers event dispatch. */
+  _updateValueAndEmitChange(event) {
+    this._updateValue(event.target.value);
+    this._emitChange(event);
+    this._updateAccessibilityMessage();
+  }
+  /**
+   * Updates `value` and `valueAsDate`. The direct update on the `_inputElement` is required
+   * to force the input change when the typed value is the same of the current one.
+   */
+  _updateValue(value) {
+    if (this._statusContainer) {
+      this._statusContainer.innerText = "";
+    }
+    if (!this._inputElement) {
+      return;
+    }
+    const time = this._parseInput(value);
+    const isTimeValid = !!time && this._isTimeValid(time);
+    const isEmptyOrValid = !value || value.trim() === "" || isTimeValid;
+    if (isEmptyOrValid && time) {
+      this._inputElement.value = this._formatValue(time);
+    }
+    const wasValid = !this._inputElement.hasAttribute("data-sbb-invalid");
+    this._inputElement.toggleAttribute("data-sbb-invalid", !isEmptyOrValid);
+    if (wasValid !== isEmptyOrValid) {
+      this._validationChange.emit({ valid: isEmptyOrValid });
+    }
+  }
+  /** Emits the change event. */
+  _emitChange(event) {
+    forwardEventToHost(event, this);
+    this._didChange.emit();
+  }
+  /** Returns the right format for the `value` property. */
+  _formatValue(time) {
+    const hours = String(time.hours).padStart(2, "0");
+    const minutes = String(time.minutes).padStart(2, "0");
+    return `${hours}:${minutes}`;
+  }
+  /**
+   * Returns the right format for the `valueAsDate` property:
+   * sets the start date at 01.01.1970, then adds the typed hours/minutes.
+   */
+  _formatValueAsDate(time) {
+    if (!time || !this._isTimeValid(time)) {
+      return null;
+    }
+    return new Date((/* @__PURE__ */ new Date(0)).setHours(time.hours, time.minutes, 0, 0));
+  }
+  /** Checks if values of hours and minutes are possible, to avoid non-existent times. */
+  _isTimeValid(time) {
+    return time.hours < 24 && time.minutes < 60;
+  }
+  /** Validate input against the defined RegExps. */
+  _parseInput(value) {
+    const trimmedValue = value == null ? void 0 : value.trim();
+    if (!trimmedValue) {
+      return null;
+    }
+    const match = trimmedValue.match(REGEX_GROUPS_WITHOUT_COLON);
+    if (match) {
+      return { hours: +match[1] || 0, minutes: +match[2] || 0 };
+    }
+    const matchColon = trimmedValue.match(REGEX_GROUPS_WITH_COLON);
+    if (matchColon) {
+      return { hours: +matchColon[1] || 0, minutes: +matchColon[2] || 0 };
+    }
+    return null;
+  }
+  /**  Only allow typing numbers and separator keys. */
+  _preventCharInsert(event) {
+    const alwaysAllowed = [
+      "Backspace",
+      "Tab",
+      "Enter",
+      "ArrowUp",
+      "ArrowDown",
+      "ArrowLeft",
+      "ArrowRight",
+      "Home",
+      "End",
+      "PageUp",
+      "PageDown",
+      "Delete"
+    ];
+    if (!event.ctrlKey && !event.altKey && !event.metaKey && !alwaysAllowed.includes(event.key) && !REGEX_ALLOWED_CHARACTERS.test(event.key)) {
+      event.preventDefault();
+    }
+  }
+  // We use a programmatic approach to avoid initial setting the message
+  // and to not immediately change output if language should change (no reason to read out message).
+  _updateAccessibilityMessage() {
+    var _a;
+    const valid = !this._inputElement.hasAttribute("data-sbb-invalid");
+    if (!valid) {
+      return;
+    }
+    this._statusContainer.innerText = `${i18nTimeInputChange[this._language.current]} ${(_a = this._inputElement) == null ? void 0 : _a.value}.`;
+  }
+  render() {
+    return html`
+      <p
+        role="status"
+        ${ref((el) => this._statusContainer = el)}
+      ></p>
+    `;
+  }
+};
+SbbTimeInputElement.styles = style;
+SbbTimeInputElement.events = {
+  didChange: "didChange",
+  validationChange: "validationChange"
+};
+__decorateClass([
+  property()
+], SbbTimeInputElement.prototype, "input", 1);
+__decorateClass([
+  state()
+], SbbTimeInputElement.prototype, "_inputElement", 2);
+SbbTimeInputElement = __decorateClass([
+  customElement("sbb-time-input")
+], SbbTimeInputElement);
+export {
+  SbbTimeInputElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"time-input.js","sources":["../../../src/elements/time-input/time-input.ts"],"sourcesContent":["import type { CSSResultGroup, TemplateResult } from 'lit';\nimport { html, LitElement } from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport { SbbLanguageController } from '../core/controllers.js';\nimport { findInput } from '../core/dom.js';\nimport { EventEmitter, forwardEventToHost } from '../core/eventing.js';\nimport { i18nTimeInputChange } from '../core/i18n.js';\nimport type { SbbDateLike, SbbValidationChangeEvent } from '../core/interfaces.js';\n\nimport style from './time-input.scss?lit&inline';\n\nconst REGEX_ALLOWED_CHARACTERS = /[0-9.:,\\-;_hH]/;\nconst REGEX_GROUPS_WITHOUT_COLON = /^([0-9]{1,2})([0-9]{2})$/;\nconst REGEX_GROUPS_WITH_COLON = /^([0-9]{1,2})?[.:,\\-;_hH]?([0-9]{1,2})?$/;\n\ninterface Time {\n  hours: number;\n  minutes: number;\n}\n\n/**\n * * Combined with a native input, it displays the input's value as a formatted time.\n *\n * @event {CustomEvent<void>} didChange - Deprecated. used for React. Will probably be removed once React 19 is available.\n * @event {CustomEvent<SbbValidationChangeEvent>} validationChange - Emits whenever the internal validation state changes.\n */\n@customElement('sbb-time-input')\nexport class SbbTimeInputElement extends LitElement {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    didChange: 'didChange',\n    validationChange: 'validationChange',\n  } as const;\n\n  /** Reference of the native input connected to the datepicker. */\n  @property()\n  public set input(value: string | HTMLElement) {\n    this._input = value;\n    this._findInputElement();\n  }\n  public get input(): string | HTMLElement | null {\n    return this._input;\n  }\n  private _input: string | HTMLElement | null = null;\n\n  @state() private _inputElement: HTMLInputElement | null = null;\n\n  /**\n   * @deprecated only used for React. Will probably be removed once React 19 is available.\n   */\n  private _didChange: EventEmitter = new EventEmitter(this, SbbTimeInputElement.events.didChange, {\n    bubbles: true,\n    cancelable: true,\n  });\n\n  /** Emits whenever the internal validation state changes. */\n  private _validationChange: EventEmitter<SbbValidationChangeEvent> = new EventEmitter(\n    this,\n    SbbTimeInputElement.events.validationChange,\n    {\n      bubbles: true,\n      composed: false,\n    },\n  );\n\n  private _statusContainer!: HTMLParagraphElement;\n  private _abortController = new AbortController();\n  private _language = new SbbLanguageController(this);\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this._findInputElement();\n    if (this._inputElement) {\n      this._updateValue(this._inputElement.value);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._abortController?.abort();\n  }\n\n  /** Gets the input value with the correct date format. */\n  // TODO: refactor this to be a get/set\n  public getValueAsDate(): Date | null {\n    return this._formatValueAsDate(this._parseInput(this._inputElement?.value));\n  }\n\n  /** Set the input value to the correctly formatted value. */\n  public setValueAsDate(date: SbbDateLike): void {\n    if (!date || !this._inputElement) {\n      return;\n    }\n    const dateObj = date instanceof Date ? date : new Date(date);\n\n    this._inputElement.value = this._formatValue({\n      hours: dateObj.getHours(),\n      minutes: dateObj.getMinutes(),\n    });\n\n    // Emit blur event when value is changed programmatically to notify\n    // frameworks that rely on that event to update form status.\n    this._inputElement.dispatchEvent(new FocusEvent('blur', { composed: true }));\n  }\n\n  private _findInputElement(): void {\n    const oldInput = this._inputElement;\n    this._inputElement = findInput(this, this.input);\n\n    if (oldInput !== this._inputElement) {\n      this._registerInputElement();\n    }\n  }\n\n  private _registerInputElement(): void {\n    this._abortController?.abort();\n\n    if (!this._inputElement) {\n      return;\n    }\n\n    this._abortController = new AbortController();\n\n    // Configure input\n    this._inputElement.toggleAttribute('data-sbb-time-input', true);\n    this._inputElement.type = 'text';\n    this._inputElement.inputMode = 'numeric';\n    this._inputElement.maxLength = 5;\n    if (!this._inputElement.placeholder) {\n      this._inputElement.placeholder = 'HH:MM';\n    }\n\n    this._inputElement.addEventListener(\n      'input',\n      (event: Event) => forwardEventToHost(event, this),\n      { signal: this._abortController.signal },\n    );\n    this._inputElement.addEventListener(\n      'keydown',\n      (event: KeyboardEvent) => this._preventCharInsert(event),\n      { signal: this._abortController.signal },\n    );\n    this._inputElement.addEventListener(\n      'change',\n      (event: Event) => this._updateValueAndEmitChange(event),\n      {\n        signal: this._abortController.signal,\n      },\n    );\n  }\n\n  /** Applies the correct format to values and triggers event dispatch. */\n  private _updateValueAndEmitChange(event: Event): void {\n    this._updateValue((event.target as HTMLInputElement).value);\n    this._emitChange(event);\n    this._updateAccessibilityMessage();\n  }\n\n  /**\n   * Updates `value` and `valueAsDate`. The direct update on the `_inputElement` is required\n   * to force the input change when the typed value is the same of the current one.\n   */\n  private _updateValue(value: string): void {\n    // Reset accessibility message\n    if (this._statusContainer) {\n      this._statusContainer.innerText = '';\n    }\n    if (!this._inputElement) {\n      return;\n    }\n\n    const time = this._parseInput(value);\n    const isTimeValid = !!time && this._isTimeValid(time);\n    const isEmptyOrValid = !value || value.trim() === '' || isTimeValid;\n    if (isEmptyOrValid && time) {\n      this._inputElement.value = this._formatValue(time);\n    }\n\n    const wasValid = !this._inputElement.hasAttribute('data-sbb-invalid');\n    this._inputElement.toggleAttribute('data-sbb-invalid', !isEmptyOrValid);\n    if (wasValid !== isEmptyOrValid) {\n      this._validationChange.emit({ valid: isEmptyOrValid });\n    }\n  }\n\n  /** Emits the change event. */\n  private _emitChange(event: Event): void {\n    forwardEventToHost(event, this);\n    this._didChange.emit();\n  }\n\n  /** Returns the right format for the `value` property. */\n  private _formatValue(time: Time): string {\n    const hours = String(time.hours).padStart(2, '0');\n    const minutes = String(time.minutes).padStart(2, '0');\n    return `${hours}:${minutes}`;\n  }\n\n  /**\n   * Returns the right format for the `valueAsDate` property:\n   * sets the start date at 01.01.1970, then adds the typed hours/minutes.\n   */\n  private _formatValueAsDate(time: Time | null | undefined): Date | null {\n    if (!time || !this._isTimeValid(time)) {\n      return null;\n    }\n\n    return new Date(new Date(0).setHours(time.hours, time.minutes, 0, 0));\n  }\n\n  /** Checks if values of hours and minutes are possible, to avoid non-existent times. */\n  private _isTimeValid(time: Time): boolean {\n    return time.hours < 24 && time.minutes < 60;\n  }\n\n  /** Validate input against the defined RegExps. */\n  private _parseInput(value: string | undefined): Time | null {\n    const trimmedValue = value?.trim();\n    if (!trimmedValue) {\n      return null;\n    }\n\n    // Special case: the input is 3 or 4 digits; split like: AB?:CD\n    const match = trimmedValue.match(REGEX_GROUPS_WITHOUT_COLON);\n    if (match) {\n      return { hours: +match[1] || 0, minutes: +match[2] || 0 };\n    }\n\n    const matchColon = trimmedValue.match(REGEX_GROUPS_WITH_COLON);\n    if (matchColon) {\n      return { hours: +matchColon[1] || 0, minutes: +matchColon[2] || 0 };\n    }\n\n    return null;\n  }\n\n  /**  Only allow typing numbers and separator keys. */\n  private _preventCharInsert(event: KeyboardEvent): void {\n    const alwaysAllowed = [\n      'Backspace',\n      'Tab',\n      'Enter',\n      'ArrowUp',\n      'ArrowDown',\n      'ArrowLeft',\n      'ArrowRight',\n      'Home',\n      'End',\n      'PageUp',\n      'PageDown',\n      'Delete',\n    ];\n\n    if (\n      !event.ctrlKey &&\n      !event.altKey &&\n      !event.metaKey &&\n      !alwaysAllowed.includes(event.key) &&\n      !REGEX_ALLOWED_CHARACTERS.test(event.key)\n    ) {\n      event.preventDefault();\n    }\n  }\n\n  // We use a programmatic approach to avoid initial setting the message\n  // and to not immediately change output if language should change (no reason to read out message).\n  private _updateAccessibilityMessage(): void {\n    const valid = !this._inputElement!.hasAttribute('data-sbb-invalid');\n    if (!valid) {\n      return;\n    }\n\n    this._statusContainer.innerText = `${i18nTimeInputChange[this._language.current]} ${\n      this._inputElement?.value\n    }.`;\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <p\n        role=\"status\"\n        ${ref((el?: Element) => (this._statusContainer = el as HTMLParagraphElement))}\n      ></p>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-time-input': SbbTimeInputElement;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/timetable-occupancy/timetable-occupancy.d.ts

@@ -0,0 +1,23 @@
+import { CSSResultGroup, TemplateResult, LitElement } from 'lit';
+import { SbbOccupancy } from '../core/interfaces.js';
+
+declare const SbbTimetableOccupancyElement_base: import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbNegativeMixinType> & typeof LitElement;
+/**
+ * Used in `sbb-timetable-row`, it displays information about wagon occupancy.
+ */
+export declare class SbbTimetableOccupancyElement extends SbbTimetableOccupancyElement_base {
+    static styles: CSSResultGroup;
+    /** Occupancy for first class wagons. */
+    firstClassOccupancy?: SbbOccupancy;
+    /** Occupancy for second class wagons. */
+    secondClassOccupancy?: SbbOccupancy;
+    private _language;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-timetable-occupancy': SbbTimetableOccupancyElement;
+    }
+}
+export {};
+//# sourceMappingURL=timetable-occupancy.d.ts.map

package/development/timetable-occupancy/timetable-occupancy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timetable-occupancy.d.ts","sourceRoot":"","sources":["../../../../src/elements/timetable-occupancy/timetable-occupancy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1D,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAKhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAK1D,OAAO,0BAA0B,CAAC;AAClC,OAAO,gCAAgC,CAAC;;AAExC;;GAEG;AACH,qBACa,4BAA6B,SAAQ,iCAA4B;IAC5E,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD,wCAAwC;IACiB,mBAAmB,CAAC,EAAE,YAAY,CAAC;IAE5F,yCAAyC;IACiB,oBAAoB,CAAC,EAAE,YAAY,CAAC;IAE9F,OAAO,CAAC,SAAS,CAAmC;cAEjC,MAAM,IAAI,cAAc;CAkC5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,yBAAyB,EAAE,4BAA4B,CAAC;KACzD;CACF"}

package/development/timetable-occupancy-icon/timetable-occupancy-icon.d.ts

@@ -0,0 +1,27 @@
+import { CSSResultGroup, PropertyValues } from 'lit';
+import { SbbOccupancy } from '../core/interfaces.js';
+import { SbbIconBase } from '../icon.js';
+
+declare const SbbTimetableOccupancyIconElement_base: import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbNegativeMixinType> & typeof SbbIconBase;
+/**
+ * It displays a wagon's occupancy icon.
+ */
+export declare class SbbTimetableOccupancyIconElement extends SbbTimetableOccupancyIconElement_base {
+    static styles: CSSResultGroup;
+    /** Wagon occupancy. */
+    occupancy: SbbOccupancy;
+    private _abort;
+    private _language;
+    private _setNameAndAriaLabel;
+    protected fetchSvgIcon(namespace: string, name: string): Promise<string>;
+    private _setAriaLabel;
+    connectedCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-timetable-occupancy-icon': SbbTimetableOccupancyIconElement;
+    }
+}
+export {};
+//# sourceMappingURL=timetable-occupancy-icon.d.ts.map

package/development/timetable-occupancy-icon/timetable-occupancy-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timetable-occupancy-icon.d.ts","sourceRoot":"","sources":["../../../../src/elements/timetable-occupancy-icon/timetable-occupancy-icon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAM1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;;AAIzC;;GAEG;AACH,qBACa,gCAAiC,SAAQ,qCAA6B;IACjF,OAAuB,MAAM,EAAE,cAAc,CAA+B;IAE5E,uBAAuB;IACJ,SAAS,EAAG,YAAY,CAAC;IAE5C,OAAO,CAAC,MAAM,CAAyC;IACvD,OAAO,CAAC,SAAS,CAA2E;YAE9E,oBAAoB;cAoBT,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvF,OAAO,CAAC,aAAa;IAOL,iBAAiB,IAAI,IAAI;cAetB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;CAO7E;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,8BAA8B,EAAE,gCAAgC,CAAC;KAClE;CACF"}

package/development/timetable-occupancy-icon.d.ts

@@ -0,0 +1,2 @@
+export * from './timetable-occupancy-icon/timetable-occupancy-icon.js';
+//# sourceMappingURL=timetable-occupancy-icon.d.ts.map

package/development/timetable-occupancy-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timetable-occupancy-icon.d.ts","sourceRoot":"","sources":["../../../src/elements/timetable-occupancy-icon.ts"],"names":[],"mappings":"AAAA,cAAc,wDAAwD,CAAC"}

package/development/timetable-occupancy-icon.js

@@ -0,0 +1,93 @@
+import { property, customElement } from "lit/decorators.js";
+import { SbbConnectedAbortController, SbbLanguageController } from "./core/controllers.js";
+import { setOrRemoveAttribute } from "./core/dom.js";
+import { i18nOccupancy } from "./core/i18n.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import { SbbIconBase } from "./icon.js";
+import { css } from "lit";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+@media (forced-colors: active) and (prefers-color-scheme: light) {
+  :host svg {
+    filter: invert(1);
+  }
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+let SbbTimetableOccupancyIconElement = class extends SbbNegativeMixin(SbbIconBase) {
+  constructor() {
+    super(...arguments);
+    this._abort = new SbbConnectedAbortController(this);
+    this._language = new SbbLanguageController(this).withHandler(() => this._setAriaLabel());
+  }
+  async _setNameAndAriaLabel() {
+    var _a, _b;
+    if (!this.occupancy) {
+      return;
+    }
+    let icon = `utilization-${this.occupancy}`;
+    if ((_a = globalThis.window) == null ? void 0 : _a.matchMedia("(forced-colors: active)").matches) {
+      icon += "-high-contrast";
+    } else if (this.negative || ((_b = globalThis.window) == null ? void 0 : _b.matchMedia("(prefer-color-scheme: dark)").matches)) {
+      icon += "-negative";
+    }
+    await this.loadSvgIcon(icon);
+  }
+  async fetchSvgIcon(namespace, name) {
+    this._setAriaLabel();
+    return super.fetchSvgIcon(namespace, name);
+  }
+  _setAriaLabel() {
+    var _a;
+    const label = (_a = i18nOccupancy[this.occupancy]) == null ? void 0 : _a[this._language.current];
+    setOrRemoveAttribute(this, "aria-label", label);
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    window.matchMedia("(forced-colors: active)").addEventListener("change", () => this._setNameAndAriaLabel(), {
+      signal: this._abort.signal
+    });
+    window.matchMedia("(prefer-color-scheme: dark)").addEventListener("change", () => this._setNameAndAriaLabel(), {
+      signal: this._abort.signal
+    });
+    this._setNameAndAriaLabel();
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("occupancy") || changedProperties.has("negative")) {
+      this._setNameAndAriaLabel();
+    }
+  }
+};
+SbbTimetableOccupancyIconElement.styles = [SbbIconBase.styles, style];
+__decorateClass([
+  property()
+], SbbTimetableOccupancyIconElement.prototype, "occupancy", 2);
+SbbTimetableOccupancyIconElement = __decorateClass([
+  customElement("sbb-timetable-occupancy-icon")
+], SbbTimetableOccupancyIconElement);
+export {
+  SbbTimetableOccupancyIconElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/timetable-occupancy.d.ts

@@ -0,0 +1,2 @@
+export * from './timetable-occupancy/timetable-occupancy.js';
+//# sourceMappingURL=timetable-occupancy.d.ts.map

package/development/timetable-occupancy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timetable-occupancy.d.ts","sourceRoot":"","sources":["../../../src/elements/timetable-occupancy.ts"],"names":[],"mappings":"AAAA,cAAc,8CAA8C,CAAC"}

package/development/timetable-occupancy.js

@@ -0,0 +1,134 @@
+import { css, LitElement, html, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { SbbLanguageController } from "./core/controllers.js";
+import { i18nClass } from "./core/i18n.js";
+import { SbbNegativeMixin } from "./core/mixins.js";
+import "./screen-reader-only.js";
+import "./timetable-occupancy-icon.js";
+const style = css`/**
+ * Better font rendering (on OS X)
+ * http://maximilianhoffmann.com/posts/better-font-rendering-on-osx
+ *
+ * Usage:
+ *
+ * .var_dark_on_light {
+ * 	@include font-smoothing;
+ * }
+ * .var_light_on_dark {
+ * 	@include font-smoothing-reset;
+ * }
+ */
+/** This mixin can be used to avoid spacing problems by inserting an invisible space as pseudo element. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-timetable-occupancy-color: var(--sbb-color-charcoal);
+  --sbb-icon-svg-width: 0.890625rem;
+  --sbb-icon-svg-height: v0.75rem;
+  display: inline-block;
+}
+@media (min-width: calc(52.5rem)) {
+  :host {
+    --sbb-icon-svg-width: 1.1875rem;
+    --sbb-icon-svg-height: v1rem;
+  }
+}
+
+:host([negative]) {
+  --sbb-timetable-occupancy-color: var(--sbb-color-white);
+}
+
+.sbb-timetable-occupancy__list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  font-size: inherit;
+  display: flex;
+  align-items: center;
+  flex-wrap: nowrap;
+  gap: var(--sbb-spacing-fixed-2x);
+}
+
+.sbb-timetable-occupancy__list-item {
+  display: flex;
+  align-items: center;
+  flex-wrap: nowrap;
+  gap: var(--sbb-spacing-fixed-1x);
+}
+
+.sbb-timetable-occupancy__list-item-class {
+  --sbb-text-font-size: var(--sbb-font-size-text-s);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: normal;
+  line-height: var(--sbb-typo-line-height-body-text);
+  letter-spacing: var(--sbb-typo-letter-spacing-body-text);
+  font-size: var(--sbb-text-font-size);
+  line-height: 1;
+  color: var(--sbb-timetable-occupancy-color);
+}
+
+.sbb-timetable-occupancy__list-item-icon {
+  display: flex;
+}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+let SbbTimetableOccupancyElement = class extends SbbNegativeMixin(LitElement) {
+  constructor() {
+    super(...arguments);
+    this._language = new SbbLanguageController(this);
+  }
+  render() {
+    return html` ${(this.firstClassOccupancy || this.secondClassOccupancy) && html`
+      <ul
+        class="sbb-timetable-occupancy__list"
+        role=${!this.firstClassOccupancy || !this.secondClassOccupancy ? "presentation" : nothing}
+      >
+        ${[this.firstClassOccupancy, this.secondClassOccupancy].map(
+      (occupancy, index) => occupancy && html`
+              <li class="sbb-timetable-occupancy__list-item">
+                <span class="sbb-timetable-occupancy__list-item-class" aria-hidden="true">
+                  ${this.firstClassOccupancy && index === 0 ? "1" : "2"}.
+                </span>
+                <sbb-screen-reader-only>
+                  ${`${i18nClass[this.firstClassOccupancy && index === 0 ? "first" : "second"][this._language.current]}.`}
+                </sbb-screen-reader-only>
+                <sbb-timetable-occupancy-icon
+                  class="sbb-timetable-occupancy__list-item-icon"
+                  ?negative=${this.negative}
+                  .occupancy=${occupancy}
+                >
+                </sbb-timetable-occupancy-icon>
+              </li>
+            `
+    )}
+      </ul>
+    `}`;
+  }
+};
+SbbTimetableOccupancyElement.styles = style;
+__decorateClass([
+  property({ attribute: "first-class-occupancy" })
+], SbbTimetableOccupancyElement.prototype, "firstClassOccupancy", 2);
+__decorateClass([
+  property({ attribute: "second-class-occupancy" })
+], SbbTimetableOccupancyElement.prototype, "secondClassOccupancy", 2);
+SbbTimetableOccupancyElement = __decorateClass([
+  customElement("sbb-timetable-occupancy")
+], SbbTimetableOccupancyElement);
+export {
+  SbbTimetableOccupancyElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/title/title-base.d.ts

@@ -0,0 +1,26 @@
+import { CSSResultGroup, PropertyValues, TemplateResult, LitElement } from 'lit';
+
+export type SbbTitleLevel = '1' | '2' | '3' | '4' | '5' | '6';
+declare const SbbTitleBase_base: import('../core/mixins.js').AbstractConstructor<import('../core/mixins.js').SbbNegativeMixinType> & typeof LitElement;
+/**
+ * It displays a title with a heading role.
+ *
+ * @slot - Use the unnamed slot to display the title.
+ */
+export declare abstract class SbbTitleBase extends SbbTitleBase_base {
+    static styles: CSSResultGroup;
+    /** Title level */
+    level: SbbTitleLevel;
+    /** Visual level for the title. Optional, if not set, the value of level will be used. */
+    visualLevel?: SbbTitleLevel;
+    /**
+     * Sometimes we need a title in the markup to present a proper hierarchy
+     * to the screen readers while we do not want to let that title appear
+     * visually. In this case we set visuallyHidden to true.
+     */
+    visuallyHidden?: boolean;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected render(): TemplateResult;
+}
+export {};
+//# sourceMappingURL=title-base.d.ts.map

package/development/title/title-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"title-base.d.ts","sourceRoot":"","sources":["../../../../src/elements/title/title-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AASjC,MAAM,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;;AAE9D;;;;GAIG;AACH,8BAGsB,YAAa,SAAQ,iBAA4B;IACrE,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD,kBAAkB;IACkB,KAAK,EAAE,aAAa,CAAO;IAE/D,yFAAyF;IAElF,WAAW,CAAC,EAAE,aAAa,CAAC;IAEnC;;;;OAIG;IAEI,cAAc,CAAC,EAAE,OAAO,CAAC;cAEb,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cAQzD,MAAM,IAAI,cAAc;CAW5C"}