@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/toast.js

@@ -0,0 +1,381 @@
+import { css, html, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { SbbOpenCloseBaseElement } from "./core/base-elements.js";
+import { SbbConnectedAbortController, SbbLanguageController, SbbSlotStateController } from "./core/controllers.js";
+import { isFirefox } from "./core/dom.js";
+import { composedPathHasAttribute } from "./core/eventing.js";
+import { i18nCloseAlert } from "./core/i18n.js";
+import { SbbIconNameMixin } from "./icon.js";
+import "./button/transparent-button.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-toast-max-width: 25rem;
+  --sbb-toast-animation-duration: var(
+    --sbb-disable-animation-zero-time,
+    var(--sbb-animation-duration-6x)
+  );
+  --sbb-toast-animation-timing-function: ease;
+  --sbb-toast-color: var(--sbb-color-white);
+  --sbb-toast-text-color: var(--sbb-color-milk);
+  --sbb-toast-background-color: var(--sbb-color-midnight);
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);
+  --sbb-toast-margin: var(--sbb-spacing-responsive-s);
+  --sbb-toast-padding-block: var(--sbb-spacing-responsive-xxxs);
+  --sbb-toast-padding-inline: var(--sbb-spacing-responsive-xs);
+  --sbb-toast-border-radius: var(--sbb-border-radius-4x);
+  --sbb-toast-container-display: flex;
+  --sbb-toast-container-position: fixed;
+  --sbb-toast-horizontal-position: initial;
+  --sbb-toast-vertical-position: initial;
+  display: block;
+}
+
+:host(:not([data-state])),
+:host([data-state=closed]) {
+  --sbb-toast-container-display: none;
+}
+
+:host([position=bottom-left]),
+:host([position=bottom-start]) {
+  --sbb-toast-horizontal-position: flex-start;
+  --sbb-toast-vertical-position: flex-end;
+}
+
+:host([position=bottom-center]) {
+  --sbb-toast-horizontal-position: center;
+  --sbb-toast-vertical-position: flex-end;
+}
+
+:host([position=bottom-right]),
+:host([position=bottom-end]) {
+  --sbb-toast-horizontal-position: flex-end;
+  --sbb-toast-vertical-position: flex-end;
+}
+
+:host([position=top-left]),
+:host([position=top-start]) {
+  --sbb-toast-horizontal-position: flex-start;
+  --sbb-toast-vertical-position: flex-start;
+}
+
+:host([position=top-center]) {
+  --sbb-toast-horizontal-position: center;
+  --sbb-toast-vertical-position: flex-start;
+}
+
+:host([position=top-right]),
+:host([position=top-end]) {
+  --sbb-toast-horizontal-position: flex-end;
+  --sbb-toast-vertical-position: flex-start;
+}
+
+.sbb-toast__overlay-container {
+  position: var(--sbb-toast-container-position);
+  pointer-events: none;
+  inset: 0;
+  display: var(--sbb-toast-container-display);
+  justify-content: var(--sbb-toast-horizontal-position);
+  align-items: var(--sbb-toast-vertical-position);
+}
+
+.sbb-toast {
+  z-index: var(--sbb-toast-z-index, var(--sbb-overlay-default-z-index));
+  pointer-events: auto;
+  margin: var(--sbb-toast-margin);
+  padding-block: var(--sbb-toast-padding-block);
+  padding-inline: var(--sbb-toast-padding-inline);
+  border-radius: var(--sbb-toast-border-radius);
+  max-width: var(--sbb-toast-max-width);
+  display: flex;
+  color: var(--sbb-toast-color);
+  background-color: var(--sbb-toast-background-color);
+}
+:host([data-state=opening]) .sbb-toast {
+  animation-name: open;
+  animation-duration: var(--sbb-toast-animation-duration);
+  animation-timing-function: var(--sbb-toast-animation-timing-function);
+}
+:host([data-state=closing]) .sbb-toast {
+  animation-name: close;
+  animation-duration: var(--sbb-toast-animation-duration);
+  animation-timing-function: var(--sbb-toast-animation-timing-function);
+}
+
+.sbb-toast__icon {
+  margin-inline-end: var(--sbb-spacing-fixed-2x);
+  line-height: initial;
+}
+:host(:not([data-slot-names~=icon], [icon-name])) .sbb-toast__icon {
+  display: none;
+}
+
+.sbb-toast__content {
+  --sbb-title-line-height: var(--sbb-typo-line-height-titles);
+  --sbb-title-margin-block-start: 0;
+  --sbb-title-margin-block-end: 0;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  margin: 0;
+  margin-block: var(--sbb-title-margin-block-start) var(--sbb-title-margin-block-end);
+  font-family: var(--sbb-typo-font-family);
+  font-weight: bold;
+  line-height: var(--sbb-title-line-height);
+  letter-spacing: var(--sbb-typo-letter-spacing-titles);
+  font-size: var(--sbb-title-font-size);
+  --sbb-title-font-size: var(--sbb-font-size-title-6);
+  --sbb-title-line-height: var(--sbb-typo-line-height-body-text);
+  color: var(--sbb-toast-text-color);
+  flex: 1 1 0;
+}
+
+.sbb-toast__action {
+  position: relative;
+  min-width: 2.5rem;
+}
+:host(:not([data-slot-names~=action], [dismissible])) .sbb-toast__action {
+  display: none;
+}
+
+::slotted([data-sbb-button]),
+.sbb-toast__action-button {
+  margin-inline: var(--sbb-spacing-fixed-2x);
+  position: absolute;
+  top: -0.625rem;
+}
+
+::slotted(:is(sbb-link, sbb-link-button, sbb-link-static)) {
+  margin-inline-start: var(--sbb-spacing-fixed-4x);
+}
+
+@keyframes open {
+  from {
+    visibility: hidden;
+    opacity: 0;
+    transform: translateY(var(--sbb-spacing-fixed-2x));
+  }
+  to {
+    visibility: visible;
+    opacity: 1;
+    transform: translateY(0%);
+  }
+}
+@keyframes close {
+  from {
+    visibility: visible;
+    opacity: 1;
+    transform: translateY(0%);
+  }
+  to {
+    visibility: hidden;
+    opacity: 0;
+    transform: translateY(var(--sbb-spacing-fixed-2x));
+  }
+}`;
+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 toastRefs = /* @__PURE__ */ new Set();
+let SbbToastElement = class extends SbbIconNameMixin(SbbOpenCloseBaseElement) {
+  constructor() {
+    super();
+    this.timeout = 6e3;
+    this.position = "bottom-center";
+    this.dismissible = false;
+    this.politeness = "polite";
+    this._abort = new SbbConnectedAbortController(this);
+    this._language = new SbbLanguageController(this);
+    new SbbSlotStateController(this);
+  }
+  /**
+   * Role of the live region. This is only for Firefox as there is a known issue where Firefox +
+   * JAWS does not read out aria-live message.
+   */
+  get _role() {
+    if (!isFirefox) {
+      return;
+    }
+    if (this.politeness === "polite") {
+      return "status";
+    } else if (this.politeness === "assertive") {
+      return "alert";
+    }
+  }
+  /**
+   * Open the toast.
+   * If there are other opened toasts in the page, close them first.
+   */
+  open() {
+    if (this.state !== "closed") {
+      return;
+    }
+    if (!this.willOpen.emit()) {
+      return;
+    }
+    this.state = "opening";
+    this._closeOtherToasts();
+  }
+  /**
+   * Close the toast.
+   */
+  close() {
+    if (this.state !== "opened") {
+      return;
+    }
+    if (!this.willClose.emit()) {
+      return;
+    }
+    clearTimeout(this._closeTimeout);
+    this.state = "closing";
+  }
+  // Close the toast on click of any element that has the 'sbb-toast-close' attribute.
+  _onClick(event) {
+    const closeElement = composedPathHasAttribute(event, "sbb-toast-close", this);
+    if (closeElement && !closeElement.hasAttribute("disabled")) {
+      this.close();
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const signal = this._abort.signal;
+    this.addEventListener("click", (e) => this._onClick(e), { signal });
+    toastRefs.add(this);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    clearTimeout(this._closeTimeout);
+    toastRefs.delete(this);
+  }
+  /**
+   * Slotted text nodes are not read correctly by screen readers on Chrome.
+   * To address the problem, if there is at least a root text node,
+   * we wrap the whole content in a <span> tag
+   */
+  _onContentSlotChange(event) {
+    const slotNodes = event.target.assignedNodes();
+    if (slotNodes.some((el) => el.nodeType === Node.TEXT_NODE)) {
+      const span = document.createElement("span");
+      this.appendChild(span);
+      span.append(...slotNodes);
+    }
+  }
+  _onActionSlotChange(event) {
+    const slotNodes = event.target.assignedNodes();
+    const buttons = slotNodes.filter(
+      (el) => el.nodeName === "SBB-TRANSPARENT-BUTTON" || el.nodeName === "SBB-TRANSPARENT-BUTTON-LINK"
+    );
+    buttons.forEach((btn) => {
+      btn.negative = true;
+      btn.size = "m";
+    });
+    const links = slotNodes.filter(
+      (el) => ["SBB-LINK", "SBB-LINK-BUTTON", "SBB-LINK-STATIC"].includes(el.nodeName)
+    );
+    links.forEach((link) => {
+      link.negative = true;
+    });
+  }
+  // In rare cases it can be that the animationEnd event is triggered twice.
+  // To avoid entering a corrupt state, exit when state is not expected.
+  _onToastAnimationEnd(event) {
+    if (event.animationName === "open" && this.state === "opening") {
+      this.state = "opened";
+      this.didOpen.emit();
+      if (this.timeout) {
+        this._closeTimeout = setTimeout(() => this.close(), this.timeout);
+      }
+    }
+    if (event.animationName === "close" && this.state === "closing") {
+      this.state = "closed";
+      this.didClose.emit();
+    }
+  }
+  /**
+   * Since we do not stack toasts, we force the closing on other existing opened ones
+   */
+  _closeOtherToasts() {
+    toastRefs.forEach((t) => {
+      if (t.getAttribute("data-state") === "opened") {
+        t.close();
+      }
+    });
+  }
+  render() {
+    return html`
+      <div class="sbb-toast__overlay-container">
+        <div
+          class="sbb-toast"
+          ${/* Firefox needs 'role' to enable screen readers */
+    ""}
+          role=${this._role ?? nothing}
+          @animationend=${this._onToastAnimationEnd}
+        >
+          <div class="sbb-toast__icon">${this.renderIconSlot()}</div>
+
+          <div class="sbb-toast__content" aria-live=${this.politeness}>
+            <slot @slotchange=${this._onContentSlotChange}></slot>
+          </div>
+
+          <div class="sbb-toast__action">
+            <slot name="action" @slotchange=${this._onActionSlotChange}>
+              ${this.dismissible ? html` <sbb-transparent-button
+                    class="sbb-toast__action-button"
+                    icon-name="cross-small"
+                    negative
+                    size="m"
+                    aria-label=${i18nCloseAlert[this._language.current]}
+                    sbb-toast-close
+                  ></sbb-transparent-button>` : nothing}
+            </slot>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+};
+SbbToastElement.styles = style;
+__decorateClass([
+  property({ type: Number })
+], SbbToastElement.prototype, "timeout", 2);
+__decorateClass([
+  property({ reflect: true })
+], SbbToastElement.prototype, "position", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], SbbToastElement.prototype, "dismissible", 2);
+__decorateClass([
+  property()
+], SbbToastElement.prototype, "politeness", 2);
+SbbToastElement = __decorateClass([
+  customElement("sbb-toast")
+], SbbToastElement);
+export {
+  SbbToastElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"toast.js","sources":["../../../src/elements/toast/toast.ts"],"sourcesContent":["import type { CSSResultGroup, TemplateResult } from 'lit';\nimport { html, nothing } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport type { SbbTransparentButtonElement, SbbTransparentButtonLinkElement } from '../button.js';\nimport { SbbOpenCloseBaseElement } from '../core/base-elements.js';\nimport {\n  SbbConnectedAbortController,\n  SbbLanguageController,\n  SbbSlotStateController,\n} from '../core/controllers.js';\nimport { isFirefox } from '../core/dom.js';\nimport { composedPathHasAttribute } from '../core/eventing.js';\nimport { i18nCloseAlert } from '../core/i18n.js';\nimport { SbbIconNameMixin } from '../icon.js';\nimport type { SbbLinkButtonElement, SbbLinkElement, SbbLinkStaticElement } from '../link.js';\nimport '../button/transparent-button.js';\n\nimport style from './toast.scss?lit&inline';\n\ntype SbbToastPositionVertical = 'top' | 'bottom';\ntype SbbToastPositionHorizontal = 'left' | 'start' | 'center' | 'right' | 'end';\nexport type SbbToastPosition = `${SbbToastPositionVertical}-${SbbToastPositionHorizontal}`;\n\n// A global collection of existing toasts\nconst toastRefs = new Set<SbbToastElement>();\n\n/**\n * It displays a toast notification.\n *\n * @slot - Use the unnamed slot to add content to the `sbb-toast`.\n * @slot icon - Assign a custom icon via slot.\n * @slot action - Provide a custom action for this toast.\n * @event {CustomEvent<void>} willOpen - Emits whenever the `sbb-toast` starts the opening transition. Can be canceled.\n * @event {CustomEvent<void>} didOpen - Emits whenever the `sbb-toast` is opened.\n * @event {CustomEvent<void>} willClose - Emits whenever the `sbb-toast` begins the closing transition. Can be canceled.\n * @event {CustomEvent<void>} didClose - Emits whenever the `sbb-toast` is closed.\n * @cssprop [--sbb-toast-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n */\n@customElement('sbb-toast')\nexport class SbbToastElement extends SbbIconNameMixin(SbbOpenCloseBaseElement) {\n  public static override styles: CSSResultGroup = style;\n\n  /**\n   * The length of time in milliseconds to wait before automatically dismissing the toast.\n   * If 0, it stays open indefinitely.\n   */\n  @property({ type: Number }) public timeout = 6000;\n\n  /** The position where to place the toast. */\n  @property({ reflect: true }) public position: SbbToastPosition = 'bottom-center';\n\n  /** Whether the toast has a close button. */\n  @property({ type: Boolean, reflect: true }) public dismissible = false;\n\n  /**\n   * The ARIA politeness level.\n   * Check https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions#live_regions for further info\n   */\n  @property() public politeness: 'polite' | 'assertive' | 'off' = 'polite';\n\n  private _closeTimeout?: ReturnType<typeof setTimeout>;\n  private _abort = new SbbConnectedAbortController(this);\n  private _language = new SbbLanguageController(this);\n\n  /**\n   * Role of the live region. This is only for Firefox as there is a known issue where Firefox +\n   * JAWS does not read out aria-live message.\n   */\n  private get _role(): 'status' | 'alert' | undefined {\n    if (!isFirefox) {\n      return;\n    }\n\n    if (this.politeness === 'polite') {\n      return 'status';\n    } else if (this.politeness === 'assertive') {\n      return 'alert';\n    }\n  }\n\n  /**\n   * Open the toast.\n   * If there are other opened toasts in the page, close them first.\n   */\n  public open(): void {\n    if (this.state !== 'closed') {\n      return;\n    }\n\n    if (!this.willOpen.emit()) {\n      return;\n    }\n    this.state = 'opening';\n    this._closeOtherToasts();\n  }\n\n  /**\n   * Close the toast.\n   */\n  public close(): void {\n    if (this.state !== 'opened') {\n      return;\n    }\n\n    if (!this.willClose.emit()) {\n      return;\n    }\n    clearTimeout(this._closeTimeout);\n    this.state = 'closing';\n  }\n\n  // Close the toast on click of any element that has the 'sbb-toast-close' attribute.\n  private _onClick(event: Event): void {\n    const closeElement = composedPathHasAttribute(event, 'sbb-toast-close', this);\n\n    if (closeElement && !closeElement.hasAttribute('disabled')) {\n      this.close();\n    }\n  }\n\n  public constructor() {\n    super();\n    new SbbSlotStateController(this);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    const signal = this._abort.signal;\n    this.addEventListener('click', (e) => this._onClick(e), { signal });\n\n    // Add this toast to the global collection\n    toastRefs.add(this);\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    clearTimeout(this._closeTimeout);\n\n    // Remove this instance\n    toastRefs.delete(this);\n  }\n\n  /**\n   * Slotted text nodes are not read correctly by screen readers on Chrome.\n   * To address the problem, if there is at least a root text node,\n   * we wrap the whole content in a <span> tag\n   */\n  private _onContentSlotChange(event: Event): void {\n    const slotNodes = (event.target as HTMLSlotElement).assignedNodes();\n\n    if (slotNodes.some((el) => el.nodeType === Node.TEXT_NODE)) {\n      const span = document.createElement('span');\n      this.appendChild(span);\n      span.append(...slotNodes);\n    }\n  }\n\n  private _onActionSlotChange(event: Event): void {\n    const slotNodes = (event.target as HTMLSlotElement).assignedNodes();\n\n    // Force the visual state on slotted buttons\n    const buttons: (SbbTransparentButtonElement | SbbTransparentButtonLinkElement)[] =\n      slotNodes.filter(\n        (el) =>\n          el.nodeName === 'SBB-TRANSPARENT-BUTTON' || el.nodeName === 'SBB-TRANSPARENT-BUTTON-LINK',\n      ) as (SbbTransparentButtonElement | SbbTransparentButtonLinkElement)[];\n    buttons.forEach((btn: SbbTransparentButtonElement | SbbTransparentButtonLinkElement) => {\n      btn.negative = true;\n      btn.size = 'm';\n    });\n\n    // Force negative on inline slotted links\n    const links = slotNodes.filter((el) =>\n      ['SBB-LINK', 'SBB-LINK-BUTTON', 'SBB-LINK-STATIC'].includes(el.nodeName),\n    ) as (SbbLinkElement | SbbLinkButtonElement | SbbLinkStaticElement)[];\n    links.forEach((link) => {\n      link.negative = true;\n    });\n  }\n\n  // In rare cases it can be that the animationEnd event is triggered twice.\n  // To avoid entering a corrupt state, exit when state is not expected.\n  private _onToastAnimationEnd(event: AnimationEvent): void {\n    // On toast opened\n    if (event.animationName === 'open' && this.state === 'opening') {\n      this.state = 'opened';\n      this.didOpen.emit();\n\n      // Start the countdown to close it\n      if (this.timeout) {\n        this._closeTimeout = setTimeout(() => this.close(), this.timeout);\n      }\n    }\n\n    // On toast closed\n    if (event.animationName === 'close' && this.state === 'closing') {\n      this.state = 'closed';\n      this.didClose.emit();\n    }\n  }\n\n  /**\n   * Since we do not stack toasts, we force the closing on other existing opened ones\n   */\n  private _closeOtherToasts(): void {\n    toastRefs.forEach((t) => {\n      if (t.getAttribute('data-state') === 'opened') {\n        t.close();\n      }\n    });\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-toast__overlay-container\">\n        <div\n          class=\"sbb-toast\"\n          ${/* Firefox needs 'role' to enable screen readers */ ''}\n          role=${this._role ?? nothing}\n          @animationend=${this._onToastAnimationEnd}\n        >\n          <div class=\"sbb-toast__icon\">${this.renderIconSlot()}</div>\n\n          <div class=\"sbb-toast__content\" aria-live=${this.politeness}>\n            <slot @slotchange=${this._onContentSlotChange}></slot>\n          </div>\n\n          <div class=\"sbb-toast__action\">\n            <slot name=\"action\" @slotchange=${this._onActionSlotChange}>\n              ${this.dismissible\n                ? html` <sbb-transparent-button\n                    class=\"sbb-toast__action-button\"\n                    icon-name=\"cross-small\"\n                    negative\n                    size=\"m\"\n                    aria-label=${i18nCloseAlert[this._language.current]}\n                    sbb-toast-close\n                  ></sbb-transparent-button>`\n                : nothing}\n            </slot>\n          </div>\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-toast': SbbToastElement;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/toggle/toggle/toggle.d.ts

@@ -0,0 +1,63 @@
+import { CSSResultGroup, LitElement, PropertyValues, TemplateResult } from 'lit';
+import { SbbToggleOptionElement } from '../toggle-option.js';
+
+/**
+ * It can be used as a container for two `sbb-toggle-option`, acting as a toggle button.
+ *
+ * @slot - Use the unnamed slot to add `<sbb-toggle-option>` elements to the toggle.
+ * @event {CustomEvent<void>} didChange - Deprecated. used for React. Will probably be removed once React 19 is available.
+ * @event {CustomEvent<void>} change - Emits whenever the toggle value changes.
+ */
+export declare class SbbToggleElement extends LitElement {
+    static styles: CSSResultGroup;
+    static readonly events: {
+        readonly didChange: "didChange";
+        readonly change: "change";
+    };
+    /** Whether the toggle is disabled. */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    private _disabled;
+    /**
+     * If true, set the width of the component fixed; if false,
+     * the width is dynamic based on the label of the sbb-toggle-option.
+     */
+    even: boolean;
+    /** Size variant, either m or s. */
+    size?: 's' | 'm';
+    /**
+     * The value of the toggle. It needs to be mutable since it is updated whenever
+     * a new option is selected (see the `onToggleOptionSelect()` method).
+     */
+    set value(value: string);
+    get value(): string;
+    private _value;
+    /** The child instances of sbb-toggle-option as an array. */
+    get options(): SbbToggleOptionElement[];
+    private _loaded;
+    private _toggleResizeObserver;
+    private _valueChanged;
+    private _updateDisabled;
+    /**
+     * @deprecated only used for React. Will probably be removed once React 19 is available.
+     * Emits whenever the toggle value changes.
+     */
+    private _didChange;
+    /** Emits whenever the toggle value changes. */
+    private _change;
+    private _abort;
+    private _setCheckedPillPosition;
+    connectedCallback(): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): Promise<void>;
+    disconnectedCallback(): void;
+    private _updateToggle;
+    private _handleInput;
+    private _handleKeyDown;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-toggle': SbbToggleElement;
+    }
+}
+//# sourceMappingURL=toggle.d.ts.map

package/development/toggle/toggle/toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.d.ts","sourceRoot":"","sources":["../../../../../src/elements/toggle/toggle/toggle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGnB,UAAU,EACV,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAQb,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAIlE;;;;;;GAMG;AACH,qBAIa,gBAAiB,SAAQ,UAAU;IAC9C,OAAuB,MAAM,EAAE,cAAc,CAAS;IACtD,gBAAuB,MAAM;;;MAGlB;IAEX,sCAAsC;IACtC,IACW,QAAQ,CAAC,KAAK,EAAE,OAAO,EAGjC;IACD,IAAW,QAAQ,IAAI,OAAO,CAE7B;IACD,OAAO,CAAC,SAAS,CAAkB;IAEnC;;;OAGG;IACgD,IAAI,EAAE,OAAO,CAAS;IAEzE,mCAAmC;IACC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,CAAO;IAE3D;;;OAGG;IACH,IACW,KAAK,CAAC,KAAK,EAAE,MAAM,EAM7B;IACD,IAAW,KAAK,IAAI,MAAM,CAIzB;IACD,OAAO,CAAC,MAAM,CAAuB;IAErC,4DAA4D;IAC5D,IAAW,OAAO,IAAI,sBAAsB,EAAE,CAE7C;IAED,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,qBAAqB,CAE3B;IAEF,OAAO,CAAC,aAAa;IAuBrB,OAAO,CAAC,eAAe;IAMvB;;;OAGG;IACH,OAAO,CAAC,UAAU,CAGf;IAEH,+CAA+C;IAC/C,OAAO,CAAC,OAAO,CAGZ;IAEH,OAAO,CAAC,MAAM,CAAyC;IAEvD,OAAO,CAAC,uBAAuB;IA6Bf,iBAAiB,IAAI,IAAI;cAShB,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7E,oBAAoB,IAAI,IAAI;IAK5C,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,cAAc;cA6BH,MAAM,IAAI,cAAc;CAO5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,YAAY,EAAE,gBAAgB,CAAC;KAChC;CACF"}

package/development/toggle/toggle-option/toggle-option.d.ts

@@ -0,0 +1,37 @@
+import { CSSResultGroup, PropertyValues, TemplateResult, LitElement } from 'lit';
+
+declare const SbbToggleOptionElement_base: import('../../core/mixins.js').AbstractConstructor<import('../../icon.js').SbbIconNameMixinType> & typeof LitElement;
+/**
+ * It displays a toggle option within a `sbb-toggle`.
+ *
+ * @slot - Use the unnamed slot to add content to the label of the toggle option.
+ * @slot icon - Slot used to render the `sbb-icon`.
+ */
+export declare class SbbToggleOptionElement extends SbbToggleOptionElement_base {
+    static styles: CSSResultGroup;
+    /** Whether the toggle-option is checked. */
+    checked: boolean;
+    /** Whether the toggle option is disabled. */
+    disabled: boolean;
+    /** Value of toggle-option. */
+    set value(value: string);
+    get value(): string;
+    private _value;
+    private _toggle?;
+    private _abort;
+    constructor();
+    connectedCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    private _uncheckOtherOptions;
+    private _handleDisabledChange;
+    private _handleInput;
+    private _verifyTabindex;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-toggle-option': SbbToggleOptionElement;
+    }
+}
+export {};
+//# sourceMappingURL=toggle-option.d.ts.map

package/development/toggle/toggle-option/toggle-option.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle-option.d.ts","sourceRoot":"","sources":["../../../../../src/elements/toggle/toggle-option/toggle-option.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1E,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;;AAWhD;;;;;GAKG;AACH,qBAIa,sBAAuB,SAAQ,2BAA4B;IACtE,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD,4CAA4C;IAErC,OAAO,UAAS;IAEvB,6CAA6C;IAEtC,QAAQ,EAAE,OAAO,CAAS;IAEjC,8BAA8B;IAC9B,IACW,KAAK,CAAC,KAAK,EAAE,MAAM,EAE7B;IACD,IAAW,KAAK,IAAI,MAAM,CAEzB;IACD,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO,CAAC,OAAO,CAAC,CAAmB;IACnC,OAAO,CAAC,MAAM,CAAyC;;IAOvC,iBAAiB,IAAI,IAAI;cAetB,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAe5E,OAAO,CAAC,oBAAoB;IAI5B,OAAO,CAAC,qBAAqB;IAc7B,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,eAAe;cAIJ,MAAM,IAAI,cAAc;CAoB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,mBAAmB,EAAE,sBAAsB,CAAC;KAC7C;CACF"}

package/development/toggle/toggle-option.d.ts

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

package/development/toggle/toggle-option.d.ts.map

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