@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/datepicker/datepicker.js

@@ -0,0 +1,381 @@
+import { css, LitElement, html } from "lit";
+import { property, state, customElement } from "lit/decorators.js";
+import { readConfig } from "../core/config.js";
+import { SbbConnectedAbortController, SbbLanguageController } from "../core/controllers.js";
+import { defaultDateAdapter } from "../core/datetime.js";
+import { findReferencedElement, findInput } from "../core/dom.js";
+import { EventEmitter } from "../core/eventing.js";
+import { i18nDatePickerPlaceholder, i18nDateChangedTo } from "../core/i18n.js";
+import { AgnosticMutationObserver } from "../core/observers.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;
+}`;
+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 FORMAT_DATE = /(^0?[1-9]?|[12]?[0-9]?|3?[01]?)[.,\\/\-\s](0?[1-9]?|1?[0-2]?)?[.,\\/\-\s](\d{1,4}$)?/;
+function getDatePicker(element, trigger) {
+  var _a;
+  if (!trigger) {
+    const parent = (_a = element.closest) == null ? void 0 : _a.call(element, "sbb-form-field");
+    return parent == null ? void 0 : parent.querySelector("sbb-datepicker");
+  }
+  return findReferencedElement(trigger);
+}
+function getAvailableDate(date, delta, dateFilter, dateAdapter) {
+  let availableDate = dateAdapter.addCalendarDays(date, delta);
+  if (dateFilter) {
+    while (!dateFilter(availableDate)) {
+      availableDate = dateAdapter.addCalendarDays(availableDate, delta);
+    }
+  }
+  return availableDate;
+}
+function findPreviousAvailableDate(date, dateFilter, dateAdapter, min) {
+  const previousDate = getAvailableDate(date, -1, dateFilter, dateAdapter);
+  const dateMin = dateAdapter.deserialize(min);
+  if (!dateMin || dateAdapter.isValid(dateMin) && dateAdapter.compareDate(previousDate, dateMin) >= 0) {
+    return previousDate;
+  }
+  return date;
+}
+function findNextAvailableDate(date, dateFilter, dateAdapter, max) {
+  const nextDate = getAvailableDate(date, 1, dateFilter, dateAdapter);
+  const dateMax = dateAdapter.deserialize(max);
+  if (!dateMax || dateAdapter.isValid(dateMax) && dateAdapter.compareDate(nextDate, dateMax) <= 0) {
+    return nextDate;
+  }
+  return date;
+}
+function isDateAvailable(date, dateFilter, min, max) {
+  const dateAdapter = defaultDateAdapter;
+  const dateMin = dateAdapter.deserialize(min);
+  const dateMax = dateAdapter.deserialize(max);
+  if (dateAdapter.isValid(dateMin) && dateAdapter.compareDate(date, dateMin) < 0 || dateAdapter.isValid(dateMax) && dateAdapter.compareDate(date, dateMax) > 0) {
+    return false;
+  }
+  return dateFilter ? dateFilter(date) : true;
+}
+const datepickerControlRegisteredEventFactory = () => new CustomEvent("datepickerControlRegistered", {
+  bubbles: false,
+  composed: true
+});
+let SbbDatepickerElement = class extends LitElement {
+  constructor() {
+    var _a;
+    super(...arguments);
+    this.wide = false;
+    this.dateFilter = () => true;
+    this._now = null;
+    this._didChange = new EventEmitter(this, SbbDatepickerElement.events.didChange, {
+      bubbles: true,
+      cancelable: true
+    });
+    this._change = new EventEmitter(this, SbbDatepickerElement.events.change, {
+      bubbles: true
+    });
+    this._inputUpdated = new EventEmitter(
+      this,
+      SbbDatepickerElement.events.inputUpdated,
+      { bubbles: true, cancelable: true }
+    );
+    this._datePickerUpdated = new EventEmitter(
+      this,
+      SbbDatepickerElement.events.datePickerUpdated,
+      {
+        bubbles: true,
+        cancelable: true
+      }
+    );
+    this._validationChange = new EventEmitter(
+      this,
+      SbbDatepickerElement.events.validationChange
+    );
+    this._inputElementState = null;
+    this._inputObserver = new AgnosticMutationObserver(this._onInputPropertiesChange.bind(this));
+    this._dateAdapter = ((_a = readConfig().datetime) == null ? void 0 : _a.dateAdapter) ?? defaultDateAdapter;
+    this._abort = new SbbConnectedAbortController(this);
+    this._language = new SbbLanguageController(this).withHandler(() => {
+      if (this._inputElement) {
+        this._inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];
+        const valueAsDate = this.getValueAsDate();
+        if (valueAsDate) {
+          this._inputElement.value = this._format(valueAsDate);
+        }
+      }
+    });
+  }
+  set now(value) {
+    this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+  }
+  get now() {
+    return this._now ?? this._dateAdapter.today();
+  }
+  get _inputElement() {
+    return this._inputElementState;
+  }
+  set _inputElement(value) {
+    const oldValue = this._inputElementState;
+    this._inputElementState = value;
+    this._registerInputElement(this._inputElementState, oldValue);
+  }
+  _findInput(newValue, oldValue) {
+    if (newValue !== oldValue) {
+      this._inputElement = findInput(this, this.input);
+    }
+  }
+  _registerInputElement(newValue, oldValue) {
+    var _a, _b;
+    if (newValue !== oldValue) {
+      (_a = this._datePickerController) == null ? void 0 : _a.abort();
+      this._datePickerController = new AbortController();
+      if (!this._inputElement) {
+        return;
+      }
+      (_b = this._inputObserver) == null ? void 0 : _b.disconnect();
+      this._inputObserver.observe(this._inputElement, {
+        attributeFilter: ["disabled", "readonly", "min", "max", "value"]
+      });
+      this._inputElement.type = "text";
+      if (!this._inputElement.placeholder) {
+        this._inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];
+      }
+      this._inputElement.addEventListener(
+        "change",
+        (event) => {
+          if (!(event instanceof CustomEvent)) {
+            this._valueChanged(event);
+          }
+        },
+        {
+          signal: this._datePickerController.signal
+        }
+      );
+    }
+  }
+  /** Gets the input value with the correct date format. */
+  getValueAsDate() {
+    if (this._inputElement && this._inputElement.value) {
+      return this._parse(this._inputElement.value);
+    }
+    return void 0;
+  }
+  /** Set the input value to the correctly formatted value. */
+  setValueAsDate(date) {
+    const parsedDate = date instanceof Date ? date : new Date(date);
+    if (this._inputElement) {
+      this._formatAndUpdateValue(this._inputElement.value, parsedDate);
+      this._inputElement.dispatchEvent(new Event("blur", { composed: true }));
+    }
+  }
+  /**
+   * @internal
+   * Whether a custom now is configured.
+   */
+  hasCustomNow() {
+    return !!this._now;
+  }
+  _onInputPropertiesChange(mutationsList) {
+    var _a, _b, _c, _d;
+    this._inputUpdated.emit({
+      disabled: (_a = this._inputElement) == null ? void 0 : _a.disabled,
+      readonly: (_b = this._inputElement) == null ? void 0 : _b.readOnly,
+      min: (_c = this._inputElement) == null ? void 0 : _c.min,
+      max: (_d = this._inputElement) == null ? void 0 : _d.max
+    });
+    if (this._inputElement && mutationsList && Array.from(mutationsList).some((e) => e.attributeName === "value")) {
+      this._inputElement.value = this._getValidValue(this._inputElement.getAttribute("value"));
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const signal = this._abort.signal;
+    this.addEventListener("datepickerControlRegistered", () => this._onInputPropertiesChange(), {
+      signal
+    });
+    this._inputElement = findInput(this, this.input);
+    if (this._inputElement) {
+      this._inputElement.value = this._getValidValue(this._inputElement.value);
+      this._inputUpdated.emit({
+        disabled: this._inputElement.disabled,
+        readonly: this._inputElement.readOnly,
+        min: this._inputElement.min,
+        max: this._inputElement.max
+      });
+    }
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("input")) {
+      this._findInput(this.input, changedProperties.get("input"));
+    }
+    if (changedProperties.has("wide") || changedProperties.has("dateFilter") || changedProperties.has("now")) {
+      this._datePickerUpdated.emit();
+    }
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    super.disconnectedCallback();
+    (_a = this._inputObserver) == null ? void 0 : _a.disconnect();
+    (_b = this._datePickerController) == null ? void 0 : _b.abort();
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this._setAriaLiveMessage(this.getValueAsDate());
+  }
+  _parseAndFormatValue(value) {
+    const d = this._parse(value);
+    return !this._dateAdapter.isValid(d) ? value : this._format(d);
+  }
+  _createAndComposeDate(value) {
+    const date = new Date(value);
+    return this._format(date);
+  }
+  _valueChanged(event) {
+    const value = event.target.value;
+    this._formatAndUpdateValue(value, this._parse(value));
+  }
+  /** Applies the correct format to values and triggers event dispatch. */
+  _formatAndUpdateValue(value, valueAsDate) {
+    var _a, _b;
+    if (this._inputElement) {
+      this._inputElement.value = !this._dateAdapter.isValid(valueAsDate) ? value : this._format(valueAsDate);
+      const isEmptyOrValid = !value || !!valueAsDate && isDateAvailable(
+        valueAsDate,
+        this.dateFilter,
+        (_a = this._inputElement) == null ? void 0 : _a.min,
+        (_b = this._inputElement) == null ? void 0 : _b.max
+      );
+      const wasValid = !this._inputElement.hasAttribute("data-sbb-invalid");
+      this._inputElement.toggleAttribute("data-sbb-invalid", !isEmptyOrValid);
+      if (wasValid !== isEmptyOrValid) {
+        this._validationChange.emit({ valid: isEmptyOrValid });
+      }
+      this._emitChange(valueAsDate);
+    }
+  }
+  /** Emits the change event. */
+  _emitChange(date) {
+    this._setAriaLiveMessage(date);
+    this._change.emit();
+    this._didChange.emit();
+    if (this._inputElement) {
+      this._inputElement.dispatchEvent(new InputEvent("input", { bubbles: true, composed: true }));
+      this._inputElement.dispatchEvent(
+        new CustomEvent("change", { bubbles: true, composed: true })
+      );
+    }
+  }
+  _getValidValue(value) {
+    if (!value) {
+      return "";
+    }
+    const match = value.match(FORMAT_DATE);
+    if ((match == null ? void 0 : match.index) === 0) {
+      return this._parseAndFormatValue(value);
+    } else if (Number.isInteger(+value)) {
+      return this._createAndComposeDate(+value);
+    } else if (this._dateAdapter.isValid(new Date(value))) {
+      return this._createAndComposeDate(value);
+    }
+    return value;
+  }
+  _parse(value) {
+    return this.dateParser ? this.dateParser(value) : this._dateAdapter.parse(value, this.now);
+  }
+  _format(date) {
+    return this.format ? this.format(date) : this._dateAdapter.format(date);
+  }
+  _setAriaLiveMessage(date) {
+    var _a, _b;
+    const ariaLiveFormatter = new Intl.DateTimeFormat(`${this._language.current}-CH`, {
+      weekday: "long"
+    });
+    const dateFormatter = new Intl.DateTimeFormat("de-CH", {
+      day: "2-digit",
+      month: "2-digit",
+      year: "numeric"
+    });
+    const containerElement = (_b = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector) == null ? void 0 : _b.call(_a, "#status-container");
+    if (containerElement) {
+      containerElement.innerText = date ? `${i18nDateChangedTo[this._language.current]} ${ariaLiveFormatter.format(
+        date
+      )}, ${dateFormatter.format(date)}` : "";
+    }
+  }
+  render() {
+    return html`<p id="status-container" role="status"></p>`;
+  }
+};
+SbbDatepickerElement.styles = style;
+SbbDatepickerElement.events = {
+  didChange: "didChange",
+  change: "change",
+  inputUpdated: "inputUpdated",
+  datePickerUpdated: "datePickerUpdated",
+  validationChange: "validationChange"
+};
+__decorateClass([
+  property({ type: Boolean })
+], SbbDatepickerElement.prototype, "wide", 2);
+__decorateClass([
+  property({ attribute: "date-filter" })
+], SbbDatepickerElement.prototype, "dateFilter", 2);
+__decorateClass([
+  property({ attribute: "date-parser" })
+], SbbDatepickerElement.prototype, "dateParser", 2);
+__decorateClass([
+  property()
+], SbbDatepickerElement.prototype, "format", 2);
+__decorateClass([
+  property()
+], SbbDatepickerElement.prototype, "input", 2);
+__decorateClass([
+  property()
+], SbbDatepickerElement.prototype, "now", 1);
+__decorateClass([
+  state()
+], SbbDatepickerElement.prototype, "_inputElement", 1);
+SbbDatepickerElement = __decorateClass([
+  customElement("sbb-datepicker")
+], SbbDatepickerElement);
+export {
+  SbbDatepickerElement,
+  datepickerControlRegisteredEventFactory,
+  findNextAvailableDate,
+  findPreviousAvailableDate,
+  getAvailableDate,
+  getDatePicker,
+  isDateAvailable
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"datepicker.js","sources":["../../../../src/elements/datepicker/datepicker/datepicker.ts"],"sourcesContent":["import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, LitElement } from 'lit';\nimport { customElement, property, state } from 'lit/decorators.js';\n\nimport { readConfig } from '../../core/config.js';\nimport { SbbConnectedAbortController, SbbLanguageController } from '../../core/controllers.js';\nimport { type DateAdapter, defaultDateAdapter } from '../../core/datetime.js';\nimport { findInput, findReferencedElement } from '../../core/dom.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { i18nDateChangedTo, i18nDatePickerPlaceholder } from '../../core/i18n.js';\nimport type { SbbDateLike, SbbValidationChangeEvent } from '../../core/interfaces.js';\nimport { AgnosticMutationObserver } from '../../core/observers.js';\nimport type { SbbDatepickerButton } from '../common.js';\nimport type { SbbDatepickerToggleElement } from '../datepicker-toggle.js';\n\nimport style from './datepicker.scss?lit&inline';\n\nconst FORMAT_DATE =\n  /(^0?[1-9]?|[12]?[0-9]?|3?[01]?)[.,\\\\/\\-\\s](0?[1-9]?|1?[0-2]?)?[.,\\\\/\\-\\s](\\d{1,4}$)?/;\n\nexport interface SbbInputUpdateEvent {\n  disabled?: boolean;\n  readonly?: boolean;\n  min?: string | number;\n  max?: string | number;\n}\n\n/**\n * Given a SbbDatepickerPreviousDayElement, a SbbDatepickerNextDayElement or a SbbDatepickerToggleElement component,\n * it returns the related SbbDatepickerElement reference, if exists.\n * @param element The element potentially connected to the SbbDatepickerElement.\n * @param trigger The id or the reference of the SbbDatePicker.\n */\nexport function getDatePicker(\n  element: SbbDatepickerButton | SbbDatepickerToggleElement,\n  trigger?: string | HTMLElement,\n): SbbDatepickerElement | null | undefined {\n  if (!trigger) {\n    const parent = element.closest?.('sbb-form-field');\n    return parent?.querySelector('sbb-datepicker');\n  }\n\n  return findReferencedElement<SbbDatepickerElement>(trigger);\n}\n\n/**\n * Returns the first available date before or after a given one, considering the SbbDatepickerElement `dateFilter` property.\n * @param date The starting date for calculations.\n * @param delta The number of days to add/subtract from the starting one.\n * @param dateFilter The dateFilter function from the SbbDatepickerElement.\n * @param dateAdapter The adapter class.\n */\nexport function getAvailableDate(\n  date: Date,\n  delta: number,\n  dateFilter: ((date: Date) => boolean) | null,\n  dateAdapter: DateAdapter<Date>,\n): Date {\n  let availableDate = dateAdapter.addCalendarDays(date, delta);\n\n  if (dateFilter) {\n    while (!dateFilter(availableDate)) {\n      availableDate = dateAdapter.addCalendarDays(availableDate, delta);\n    }\n  }\n\n  return availableDate;\n}\n\n/**\n * Calculates the first available date before the given one,\n * considering the SbbDatepickerElement `dateFilter` property and `min` parameter (e.g. from the self-named input's attribute).\n * @param date The starting date for calculations.\n * @param dateFilter The dateFilter function from the SbbDatepickerElement.\n * @param dateAdapter The adapter class.\n * @param min The minimum value to consider in calculations.\n */\nexport function findPreviousAvailableDate(\n  date: Date,\n  dateFilter: ((date: Date) => boolean) | null,\n  dateAdapter: DateAdapter<Date>,\n  min: string | number | null,\n): Date {\n  const previousDate = getAvailableDate(date, -1, dateFilter, dateAdapter);\n  const dateMin = dateAdapter.deserialize(min);\n\n  if (\n    !dateMin ||\n    (dateAdapter.isValid(dateMin) && dateAdapter.compareDate(previousDate, dateMin) >= 0)\n  ) {\n    return previousDate;\n  }\n  return date;\n}\n\n/**\n * Calculates the first available date after the given one,\n * considering the SbbDatepickerElement `dateFilter` property and `max` parameter (e.g. from the self-named input's attribute).\n * @param date The starting date for calculations.\n * @param dateFilter The dateFilter function from the SbbDatepickerElement.\n * @param dateAdapter The adapter class.\n * @param max The maximum value to consider in calculations.\n */\nexport function findNextAvailableDate(\n  date: Date,\n  dateFilter: ((date: Date) => boolean) | null,\n  dateAdapter: DateAdapter<Date>,\n  max: string | number | null,\n): Date {\n  const nextDate = getAvailableDate(date, 1, dateFilter, dateAdapter);\n  const dateMax = dateAdapter.deserialize(max);\n\n  if (\n    !dateMax ||\n    (dateAdapter.isValid(dateMax) && dateAdapter.compareDate(nextDate, dateMax) <= 0)\n  ) {\n    return nextDate;\n  }\n  return date;\n}\n\n/**\n * Checks if the provided date is a valid one, considering the SbbDatepickerElement `dateFilter` property\n * and `min` and `max` parameters (e.g. from the self-named input's attributes).\n * @param date The starting date for calculations.\n * @param dateFilter The dateFilter function from the SbbDatepickerElement.\n * @param min The minimum value to consider in calculations.\n * @param max The maximum value to consider in calculations.\n */\nexport function isDateAvailable(\n  date: Date,\n  dateFilter: ((date: Date) => boolean) | null,\n  min: string | number | null | undefined,\n  max: string | number | null | undefined,\n): boolean {\n  // TODO: Get date adapter from config\n  const dateAdapter: DateAdapter<Date> = defaultDateAdapter;\n  const dateMin = dateAdapter.deserialize(min);\n  const dateMax = dateAdapter.deserialize(max);\n\n  if (\n    (dateAdapter.isValid(dateMin) && dateAdapter.compareDate(date, dateMin!) < 0) ||\n    (dateAdapter.isValid(dateMax) && dateAdapter.compareDate(date, dateMax!) > 0)\n  ) {\n    return false;\n  }\n\n  return dateFilter ? dateFilter(date) : true;\n}\n\nexport const datepickerControlRegisteredEventFactory = (): CustomEvent =>\n  new CustomEvent('datepickerControlRegistered', {\n    bubbles: false,\n    composed: true,\n  });\n\n/**\n * Combined with a native input, it displays the input's value as a formatted date.\n *\n * @event {CustomEvent<void>} didChange - Deprecated. used for React. Will probably be removed once React 19 is available.\n * @event {CustomEvent<void>} change - Notifies that the connected input has changes.\n * @event {CustomEvent<SbbInputUpdateEvent>} inputUpdated - Notifies that the attributes of the input connected to the datepicker have changes.\n * @event {CustomEvent<void>} datePickerUpdated - Notifies that the attributes of the datepicker have changes.\n * @event {CustomEvent<SbbValidationChangeEvent>} validationChange - Emits whenever the internal validation state changes.\n */\n@customElement('sbb-datepicker')\nexport class SbbDatepickerElement extends LitElement {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    didChange: 'didChange',\n    change: 'change',\n    inputUpdated: 'inputUpdated',\n    datePickerUpdated: 'datePickerUpdated',\n    validationChange: 'validationChange',\n  } as const;\n\n  /** If set to true, two months are displayed. */\n  @property({ type: Boolean }) public wide = false;\n\n  /** A function used to filter out dates. */\n  @property({ attribute: 'date-filter' }) public dateFilter: (date: Date | null) => boolean = () =>\n    true;\n\n  /** A function used to parse string value into dates. */\n  @property({ attribute: 'date-parser' }) public dateParser?: (value: string) => Date | undefined;\n\n  /** A function used to format dates into the preferred string format. */\n  @property() public format?: (date: Date) => string;\n\n  /** Reference of the native input connected to the datepicker. */\n  @property() public input?: string | HTMLElement;\n\n  /** A configured date which acts as the current date instead of the real current date. Recommended for testing purposes. */\n  @property()\n  public set now(value: SbbDateLike | undefined) {\n    this._now = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  public get now(): Date {\n    return this._now ?? this._dateAdapter.today();\n  }\n  private _now: Date | 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, SbbDatepickerElement.events.didChange, {\n    bubbles: true,\n    cancelable: true,\n  });\n\n  /** Notifies that the connected input has changes. */\n  private _change: EventEmitter = new EventEmitter(this, SbbDatepickerElement.events.change, {\n    bubbles: true,\n  });\n\n  /** Notifies that the attributes of the input connected to the datepicker have changes. */\n  private _inputUpdated: EventEmitter<SbbInputUpdateEvent> = new EventEmitter(\n    this,\n    SbbDatepickerElement.events.inputUpdated,\n    { bubbles: true, cancelable: true },\n  );\n\n  /** Notifies that the attributes of the datepicker have changes. */\n  private _datePickerUpdated: EventEmitter = new EventEmitter(\n    this,\n    SbbDatepickerElement.events.datePickerUpdated,\n    {\n      bubbles: true,\n      cancelable: true,\n    },\n  );\n\n  /** Emits whenever the internal validation state changes. */\n  private _validationChange: EventEmitter<SbbValidationChangeEvent> = new EventEmitter(\n    this,\n    SbbDatepickerElement.events.validationChange,\n  );\n\n  @state() private get _inputElement(): HTMLInputElement | null {\n    return this._inputElementState;\n  }\n\n  private set _inputElement(value) {\n    const oldValue = this._inputElementState;\n    this._inputElementState = value;\n    this._registerInputElement(this._inputElementState, oldValue);\n  }\n\n  private _inputElementState: HTMLInputElement | null = null;\n\n  private _findInput(newValue: string | HTMLElement, oldValue: string | HTMLElement): void {\n    if (newValue !== oldValue) {\n      this._inputElement = findInput(this, this.input);\n    }\n  }\n  private _registerInputElement(\n    newValue: HTMLInputElement | null,\n    oldValue: HTMLInputElement | null,\n  ): void {\n    if (newValue !== oldValue) {\n      this._datePickerController?.abort();\n      this._datePickerController = new AbortController();\n\n      if (!this._inputElement) {\n        return;\n      }\n\n      this._inputObserver?.disconnect();\n      this._inputObserver.observe(this._inputElement, {\n        attributeFilter: ['disabled', 'readonly', 'min', 'max', 'value'],\n      });\n\n      this._inputElement.type = 'text';\n\n      if (!this._inputElement.placeholder) {\n        this._inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];\n      }\n\n      this._inputElement.addEventListener(\n        'change',\n        (event: Event) => {\n          if (!(event instanceof CustomEvent)) {\n            this._valueChanged(event);\n          }\n        },\n        {\n          signal: this._datePickerController.signal,\n        },\n      );\n    }\n  }\n\n  /** Gets the input value with the correct date format. */\n  public getValueAsDate(): Date | undefined {\n    if (this._inputElement && this._inputElement.value) {\n      return this._parse(this._inputElement.value);\n    }\n    return undefined;\n  }\n\n  /** Set the input value to the correctly formatted value. */\n  public setValueAsDate(date: SbbDateLike): void {\n    const parsedDate = date instanceof Date ? date : new Date(date);\n    if (this._inputElement) {\n      this._formatAndUpdateValue(this._inputElement.value, parsedDate);\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 Event('blur', { composed: true }));\n    }\n  }\n\n  /**\n   * @internal\n   * Whether a custom now is configured.\n   */\n  public hasCustomNow(): boolean {\n    return !!this._now;\n  }\n\n  private _onInputPropertiesChange(mutationsList?: MutationRecord[]): void {\n    this._inputUpdated.emit({\n      disabled: this._inputElement?.disabled,\n      readonly: this._inputElement?.readOnly,\n      min: this._inputElement?.min,\n      max: this._inputElement?.max,\n    });\n\n    if (\n      this._inputElement &&\n      mutationsList &&\n      Array.from(mutationsList).some((e) => e.attributeName === 'value')\n    ) {\n      this._inputElement.value = this._getValidValue(this._inputElement.getAttribute('value')!);\n    }\n  }\n\n  private _datePickerController!: AbortController;\n\n  private _inputObserver = new AgnosticMutationObserver(this._onInputPropertiesChange.bind(this));\n\n  private _dateAdapter: DateAdapter<Date> =\n    readConfig().datetime?.dateAdapter ?? defaultDateAdapter;\n\n  private _abort = new SbbConnectedAbortController(this);\n  private _language = new SbbLanguageController(this).withHandler(() => {\n    if (this._inputElement) {\n      this._inputElement.placeholder = i18nDatePickerPlaceholder[this._language.current];\n      const valueAsDate = this.getValueAsDate();\n      if (valueAsDate) {\n        this._inputElement.value = this._format(valueAsDate);\n      }\n    }\n  });\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    const signal = this._abort.signal;\n    this.addEventListener('datepickerControlRegistered', () => this._onInputPropertiesChange(), {\n      signal,\n    });\n    this._inputElement = findInput(this, this.input);\n    if (this._inputElement) {\n      this._inputElement.value = this._getValidValue(this._inputElement.value);\n      this._inputUpdated.emit({\n        disabled: this._inputElement.disabled,\n        readonly: this._inputElement.readOnly,\n        min: this._inputElement.min,\n        max: this._inputElement.max,\n      });\n    }\n  }\n\n  public override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('input')) {\n      this._findInput(this.input!, changedProperties.get('input')!);\n    }\n    if (\n      changedProperties.has('wide') ||\n      changedProperties.has('dateFilter') ||\n      changedProperties.has('now')\n    ) {\n      this._datePickerUpdated.emit();\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._inputObserver?.disconnect();\n    this._datePickerController?.abort();\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n    this._setAriaLiveMessage(this.getValueAsDate());\n  }\n\n  private _parseAndFormatValue(value: string): string {\n    const d = this._parse(value);\n    return !this._dateAdapter.isValid(d) ? value : this._format(d!);\n  }\n\n  private _createAndComposeDate(value: SbbDateLike): string {\n    const date = new Date(value);\n    return this._format(date);\n  }\n\n  private _valueChanged(event: Event): void {\n    const value: string = (event.target as HTMLInputElement).value;\n    this._formatAndUpdateValue(value, this._parse(value));\n  }\n\n  /** Applies the correct format to values and triggers event dispatch. */\n  private _formatAndUpdateValue(value: string, valueAsDate: Date | null | undefined): void {\n    if (this._inputElement) {\n      this._inputElement.value = !this._dateAdapter.isValid(valueAsDate)\n        ? value\n        : this._format(valueAsDate!);\n\n      const isEmptyOrValid =\n        !value ||\n        (!!valueAsDate &&\n          isDateAvailable(\n            valueAsDate,\n            this.dateFilter,\n            this._inputElement?.min,\n            this._inputElement?.max,\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      this._emitChange(valueAsDate!);\n    }\n  }\n\n  /** Emits the change event. */\n  private _emitChange(date: Date): void {\n    this._setAriaLiveMessage(date);\n\n    this._change.emit();\n    this._didChange.emit();\n\n    if (this._inputElement) {\n      this._inputElement.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true }));\n      this._inputElement.dispatchEvent(\n        new CustomEvent('change', { bubbles: true, composed: true }),\n      );\n    }\n  }\n\n  private _getValidValue(value: string): string {\n    if (!value) {\n      return '';\n    }\n\n    const match: RegExpMatchArray | null = value.match(FORMAT_DATE);\n\n    if (match?.index === 0) {\n      return this._parseAndFormatValue(value);\n    } else if (Number.isInteger(+value)) {\n      return this._createAndComposeDate(+value);\n    } else if (this._dateAdapter.isValid(new Date(value))) {\n      return this._createAndComposeDate(value);\n    }\n\n    return value;\n  }\n\n  private _parse(value: string): Date | undefined {\n    return this.dateParser ? this.dateParser(value) : this._dateAdapter.parse(value, this.now);\n  }\n\n  private _format(date: Date): string {\n    return this.format ? this.format(date) : this._dateAdapter.format(date);\n  }\n\n  private _setAriaLiveMessage(date?: Date): void {\n    const ariaLiveFormatter = new Intl.DateTimeFormat(`${this._language.current}-CH`, {\n      weekday: 'long',\n    });\n\n    const dateFormatter = new Intl.DateTimeFormat('de-CH', {\n      day: '2-digit',\n      month: '2-digit',\n      year: 'numeric',\n    });\n\n    const containerElement: HTMLParagraphElement | null | undefined =\n      this.shadowRoot?.querySelector?.<HTMLParagraphElement>('#status-container');\n\n    if (containerElement) {\n      containerElement.innerText = date\n        ? `${i18nDateChangedTo[this._language.current]} ${ariaLiveFormatter.format(\n            date,\n          )}, ${dateFormatter.format(date)}`\n        : '';\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`<p id=\"status-container\" role=\"status\"></p>`;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-datepicker': SbbDatepickerElement;\n  }\n\n  interface GlobalEventHandlersEventMap {\n    inputUpdated: CustomEvent<SbbInputUpdateEvent>;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/datepicker.d.ts

@@ -0,0 +1,6 @@
+export * from './datepicker/datepicker.js';
+export * from './datepicker/datepicker-next-day.js';
+export * from './datepicker/datepicker-previous-day.js';
+export * from './datepicker/datepicker-toggle.js';
+export * from './datepicker/common.js';
+//# sourceMappingURL=datepicker.d.ts.map

package/development/datepicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datepicker.d.ts","sourceRoot":"","sources":["../../../src/elements/datepicker.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC"}

package/development/datepicker.js

@@ -0,0 +1,6 @@
+export * from "./datepicker/datepicker.js";
+export * from "./datepicker/datepicker-next-day.js";
+export * from "./datepicker/datepicker-previous-day.js";
+export * from "./datepicker/datepicker-toggle.js";
+export * from "./datepicker/common.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXBpY2tlci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OyJ9

package/development/dialog/dialog/dialog.d.ts

@@ -0,0 +1,54 @@
+import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
+import { SbbOverlayBaseElement } from '../../overlay.js';
+
+/**
+ * It displays an interactive overlay element.
+ *
+ * @slot - Use the unnamed slot to provide a `sbb-dialog-title`, `sbb-dialog-content` and an optional `sbb-dialog-actions`.
+ * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-dialog` starts the opening transition. Can be canceled.
+ * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-dialog` is opened.
+ * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-dialog` begins the closing transition. Can be canceled.
+ * @event {CustomEvent<SbbOverlayCloseEventDetails>} didClose - Emits whenever the `sbb-dialog` is closed.
+ * @cssprop [--sbb-dialog-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+ * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+ * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+ */
+export declare class SbbDialogElement extends SbbOverlayBaseElement {
+    static styles: CSSResultGroup;
+    /** Backdrop click action. */
+    backdropAction: 'close' | 'none';
+    private _dialogContentResizeObserver;
+    private _dialogTitleElement;
+    private _dialogTitleHeight?;
+    private _dialogContentElement;
+    private _dialogActionsElement;
+    private _isPointerDownEventOnDialog;
+    private _overflows;
+    private _lastScroll;
+    private _dialogId;
+    protected closeAttribute: string;
+    /** Opens the component. */
+    open(): void;
+    connectedCallback(): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    protected attachOpenOverlayEvents(): void;
+    protected onOverlayAnimationEnd(event: AnimationEvent): void;
+    protected setOverlayFocus(): void;
+    private _syncNegative;
+    private _onContentScroll;
+    private _pointerDownListener;
+    private _closeOnBackdropClick;
+    private _setDialogHeaderHeight;
+    private _onContentResize;
+    private _setHideHeaderDataAttribute;
+    private _setOverflowsDataAttribute;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-dialog': SbbDialogElement;
+    }
+}
+//# sourceMappingURL=dialog.d.ts.map

package/development/dialog/dialog/dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.d.ts","sourceRoot":"","sources":["../../../../../src/elements/dialog/dialog/dialog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAQ1E,OAAO,EAAe,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAMtE,OAAO,6BAA6B,CAAC;AAIrC;;;;;;;;;;;GAWG;AACH,qBACa,gBAAiB,SAAQ,qBAAqB;IACzD,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD,6BAA6B;IACsB,cAAc,EAAE,OAAO,GAAG,MAAM,CAAW;IAM9F,OAAO,CAAC,4BAA4B,CAElC;IAEF,OAAO,CAAC,mBAAmB,CAAsC;IACjE,OAAO,CAAC,kBAAkB,CAAC,CAAS;IACpC,OAAO,CAAC,qBAAqB,CAA4B;IACzD,OAAO,CAAC,qBAAqB,CAAwC;IACrE,OAAO,CAAC,2BAA2B,CAAkB;IACrD,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,SAAS,CAA4B;IAC7C,SAAS,CAAC,cAAc,EAAE,MAAM,CAAsB;IAEtD,2BAA2B;IACpB,IAAI,IAAI,IAAI;IA2BH,iBAAiB,IAAI,IAAI;cAYtB,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cAO3D,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAQ5D,oBAAoB,IAAI,IAAI;cAKzB,uBAAuB,IAAI,IAAI;IAgBlD,SAAS,CAAC,qBAAqB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAoC5D,SAAS,CAAC,eAAe,IAAI,IAAI;IAQjC,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,gBAAgB;IAqCxB,OAAO,CAAC,oBAAoB,CAS1B;IAGF,OAAO,CAAC,qBAAqB,CAc3B;IAEF,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,0BAA0B;cAMf,MAAM,IAAI,cAAc;CAmB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,YAAY,EAAE,gBAAgB,CAAC;KAChC;CACF"}

package/development/dialog/dialog-actions/dialog-actions.d.ts

@@ -0,0 +1,18 @@
+import { CSSResultGroup, TemplateResult } from 'lit';
+import { SbbActionGroupElement } from '../../action-group.js';
+
+/**
+ * Use this component to display a footer into an `sbb-dialog` with an action group.
+ *
+ * @slot - Use the unnamed slot to add `sbb-block-link` or `sbb-button` elements to the `sbb-dialog-actions`.
+ */
+export declare class SbbDialogActionsElement extends SbbActionGroupElement {
+    static styles: CSSResultGroup;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-dialog-actions': SbbDialogActionsElement;
+    }
+}
+//# sourceMappingURL=dialog-actions.d.ts.map

package/development/dialog/dialog-actions/dialog-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog-actions.d.ts","sourceRoot":"","sources":["../../../../../src/elements/dialog/dialog-actions/dialog-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAI1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAI9D;;;;GAIG;AACH,qBACa,uBAAwB,SAAQ,qBAAqB;IAChE,OAAuB,MAAM,EAAE,cAAc,CAAyC;cAEnE,MAAM,IAAI,cAAc;CAG5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,oBAAoB,EAAE,uBAAuB,CAAC;KAC/C;CACF"}

package/development/dialog/dialog-actions.d.ts

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

package/development/dialog/dialog-actions.d.ts.map

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

package/development/dialog/dialog-actions.js

@@ -0,0 +1,66 @@
+import { css, html } from "lit";
+import { customElement } from "lit/decorators.js";
+import { SbbActionGroupElement } from "../action-group.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 {
+  display: contents;
+}
+@media (forced-colors: active) {
+  :host {
+    --sbb-dialog-actions-border: var(--sbb-border-width-1x) solid CanvasText;
+  }
+}
+
+.sbb-dialog-actions {
+  padding-inline: var(--sbb-dialog-padding-inline);
+  padding-block: var(--sbb-spacing-responsive-s);
+  margin-block-start: auto;
+  background-color: var(--sbb-dialog-background-color);
+  border-block-start: var(--sbb-dialog-actions-border);
+}
+:host([data-overflows]:not([data-negative])) .sbb-dialog-actions {
+  box-shadow: var(--sbb-shadow-elevation-level-9-shadow-2-offset-x) var(--sbb-shadow-elevation-level-9-shadow-2-offset-y) var(--sbb-shadow-elevation-level-9-shadow-2-blur) var(--sbb-shadow-elevation-level-9-shadow-2-spread) var(--sbb-shadow-elevation-level-9-soft-2-color), var(--sbb-shadow-elevation-level-9-shadow-1-offset-x) var(--sbb-shadow-elevation-level-9-shadow-1-offset-y) var(--sbb-shadow-elevation-level-9-shadow-1-blur) var(--sbb-shadow-elevation-level-9-shadow-1-spread) var(--sbb-shadow-elevation-level-9-soft-1-color);
+}`;
+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 SbbDialogActionsElement = class extends SbbActionGroupElement {
+  render() {
+    return html` <div class="sbb-dialog-actions">${super.render()}</div> `;
+  }
+};
+SbbDialogActionsElement.styles = [SbbActionGroupElement.styles, style];
+SbbDialogActionsElement = __decorateClass([
+  customElement("sbb-dialog-actions")
+], SbbDialogActionsElement);
+export {
+  SbbDialogActionsElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLWFjdGlvbnMuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9kaWFsb2cvZGlhbG9nLWFjdGlvbnMvZGlhbG9nLWFjdGlvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDU1NSZXN1bHRHcm91cCwgVGVtcGxhdGVSZXN1bHQgfSBmcm9tICdsaXQnO1xuaW1wb3J0IHsgaHRtbCB9IGZyb20gJ2xpdCc7XG5pbXBvcnQgeyBjdXN0b21FbGVtZW50IH0gZnJvbSAnbGl0L2RlY29yYXRvcnMuanMnO1xuXG5pbXBvcnQgeyBTYmJBY3Rpb25Hcm91cEVsZW1lbnQgfSBmcm9tICcuLi8uLi9hY3Rpb24tZ3JvdXAuanMnO1xuXG5pbXBvcnQgc3R5bGUgZnJvbSAnLi9kaWFsb2ctYWN0aW9ucy5zY3NzP2xpdCZpbmxpbmUnO1xuXG4vKipcbiAqIFVzZSB0aGlzIGNvbXBvbmVudCB0byBkaXNwbGF5IGEgZm9vdGVyIGludG8gYW4gYHNiYi1kaWFsb2dgIHdpdGggYW4gYWN0aW9uIGdyb3VwLlxuICpcbiAqIEBzbG90IC0gVXNlIHRoZSB1bm5hbWVkIHNsb3QgdG8gYWRkIGBzYmItYmxvY2stbGlua2Agb3IgYHNiYi1idXR0b25gIGVsZW1lbnRzIHRvIHRoZSBgc2JiLWRpYWxvZy1hY3Rpb25zYC5cbiAqL1xuQGN1c3RvbUVsZW1lbnQoJ3NiYi1kaWFsb2ctYWN0aW9ucycpXG5leHBvcnQgY2xhc3MgU2JiRGlhbG9nQWN0aW9uc0VsZW1lbnQgZXh0ZW5kcyBTYmJBY3Rpb25Hcm91cEVsZW1lbnQge1xuICBwdWJsaWMgc3RhdGljIG92ZXJyaWRlIHN0eWxlczogQ1NTUmVzdWx0R3JvdXAgPSBbU2JiQWN0aW9uR3JvdXBFbGVtZW50LnN0eWxlcywgc3R5bGVdO1xuXG4gIHByb3RlY3RlZCBvdmVycmlkZSByZW5kZXIoKTogVGVtcGxhdGVSZXN1bHQge1xuICAgIHJldHVybiBodG1sYCA8ZGl2IGNsYXNzPVwic2JiLWRpYWxvZy1hY3Rpb25zXCI+JHtzdXBlci5yZW5kZXIoKX08L2Rpdj4gYDtcbiAgfVxufVxuXG5kZWNsYXJlIGdsb2JhbCB7XG4gIGludGVyZmFjZSBIVE1MRWxlbWVudFRhZ05hbWVNYXAge1xuICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbmFtaW5nLWNvbnZlbnRpb25cbiAgICAnc2JiLWRpYWxvZy1hY3Rpb25zJzogU2JiRGlhbG9nQWN0aW9uc0VsZW1lbnQ7XG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQWNhLElBQUEsMEJBQU4sY0FBc0Msc0JBQXNCO0FBQUEsRUFHOUMsU0FBeUI7QUFDbkMsV0FBQSx3Q0FBd0MsTUFBTSxPQUFRLENBQUE7QUFBQSxFQUMvRDtBQUNGO0FBTmEsd0JBQ1ksU0FBeUIsQ0FBQyxzQkFBc0IsUUFBUSxLQUFLO0FBRHpFLDBCQUFOLGdCQUFBO0FBQUEsRUFETixjQUFjLG9CQUFvQjtBQUFBLEdBQ3RCLHVCQUFBOyJ9

package/development/dialog/dialog-content/dialog-content.d.ts

@@ -0,0 +1,17 @@
+import { CSSResultGroup, TemplateResult, LitElement } from 'lit';
+
+/**
+ * Use this component to provide a content for an `sbb-dialog`.
+ *
+ * @slot - Use the unnamed slot to provide a dialog content.
+ */
+export declare class SbbDialogContentElement extends LitElement {
+    static styles: CSSResultGroup;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-dialog-content': SbbDialogContentElement;
+    }
+}
+//# sourceMappingURL=dialog-content.d.ts.map

package/development/dialog/dialog-content/dialog-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog-content.d.ts","sourceRoot":"","sources":["../../../../../src/elements/dialog/dialog-content/dialog-content.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1D,OAAO,EAAQ,UAAU,EAAE,MAAM,KAAK,CAAC;AAKvC;;;;GAIG;AACH,qBACa,uBAAwB,SAAQ,UAAU;IACrD,OAAuB,MAAM,EAAE,cAAc,CAAS;cAEnC,MAAM,IAAI,cAAc;CAO5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,oBAAoB,EAAE,uBAAuB,CAAC;KAC/C;CACF"}

package/development/dialog/dialog-content.d.ts

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

package/development/dialog/dialog-content.d.ts.map

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