@sbb-esta/lyne-elements 0.0.0 → 0.52.0

package/development/toggle/toggle-option.js

@@ -0,0 +1,222 @@
+import { css, LitElement, html, nothing } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { SbbConnectedAbortController, SbbSlotStateController } from "../core/controllers.js";
+import { hostAttributes } from "../core/decorators.js";
+import { setOrRemoveAttribute } from "../core/dom.js";
+import { SbbIconNameMixin } from "../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-toggle-option-cursor: pointer;
+  --sbb-toggle-option-color: var(--sbb-color-anthracite);
+  --sbb-toggle-option-icon-min-size: var(--sbb-size-icon-ui-small);
+  --sbb-toggle-option-border-radius: var(--sbb-border-radius-infinity);
+  --sbb-toggle-option-line-height: calc(1em * var(--sbb-typo-line-height-body-text));
+  display: inline-block;
+  min-width: var(--sbb-toggle-min-width);
+  overflow: hidden;
+  z-index: 1;
+}
+
+:host(:focus-visible:not([data-focus-origin=mouse], [data-focus-origin=touch])) {
+  outline: none !important;
+}
+
+:host([checked]) {
+  --sbb-toggle-option-color: var(--sbb-color-charcoal);
+}
+
+:host([disabled]) {
+  --sbb-toggle-option-cursor: unset;
+  --sbb-toggle-option-color: var(--sbb-color-granite);
+}
+
+input[type=radio] {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+  width: 1px;
+}
+
+.sbb-toggle-option {
+  --sbb-text-font-size: var(--sbb-font-size-text-xs);
+  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);
+  font-weight: bold;
+  cursor: var(--sbb-toggle-option-cursor);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: var(--sbb-toggle-height);
+  padding-inline: var(--sbb-toggle-padding-inline);
+  border-radius: var(--sbb-toggle-option-border-radius);
+  color: var(--sbb-toggle-option-color);
+}
+:host([data-slot-names~=unnamed]:where([data-slot-names~=icon], [icon-name])) .sbb-toggle-option {
+  gap: var(--sbb-spacing-fixed-1x);
+}
+
+.sbb-toggle-option__label {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+:host(:focus-visible:not([data-focus-origin=mouse], [data-focus-origin=touch])) .sbb-toggle-option__label::before {
+  content: "";
+  position: absolute;
+  pointer-events: none;
+  inset: calc(var(--sbb-focus-outline-offset) * -2);
+  border: var(--sbb-focus-outline-color) solid var(--sbb-focus-outline-width);
+  border-radius: var(--sbb-toggle-option-border-radius);
+}
+
+sbb-icon,
+::slotted(sbb-icon) {
+  min-width: var(--sbb-toggle-option-icon-min-size);
+  min-height: var(--sbb-toggle-option-icon-min-size);
+}`;
+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 SbbToggleOptionElement = class extends SbbIconNameMixin(LitElement) {
+  constructor() {
+    super();
+    this.checked = false;
+    this.disabled = false;
+    this._value = "";
+    this._abort = new SbbConnectedAbortController(this);
+    new SbbSlotStateController(this);
+  }
+  set value(value) {
+    this._value = `${value}`;
+  }
+  get value() {
+    return this._value;
+  }
+  connectedCallback() {
+    var _a;
+    super.connectedCallback();
+    const signal = this._abort.signal;
+    this.addEventListener("input", () => this._handleInput(), { signal });
+    this.addEventListener("click", () => {
+      var _a2;
+      return (_a2 = this.shadowRoot.querySelector("label")) == null ? void 0 : _a2.click();
+    }, {
+      signal
+    });
+    this._toggle = ((_a = this.closest) == null ? void 0 : _a.call(this, "sbb-toggle")) ?? void 0;
+    this._verifyTabindex();
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("checked")) {
+      this.setAttribute("aria-checked", `${this.checked}`);
+      this._verifyTabindex();
+      if (this.checked) {
+        this._uncheckOtherOptions();
+      }
+    }
+    if (changedProperties.has("disabled")) {
+      this._handleDisabledChange();
+    }
+  }
+  _uncheckOtherOptions() {
+    var _a;
+    (_a = this._toggle) == null ? void 0 : _a.options.filter((o) => o !== this).forEach((o) => o.checked = false);
+  }
+  _handleDisabledChange() {
+    if (!this._toggle)
+      ;
+    else if (this._toggle.disabled && !this.disabled) {
+      this.disabled = true;
+    } else if (!this._toggle.disabled && this.disabled) {
+      this.disabled = false;
+    }
+    setOrRemoveAttribute(this, "aria-disabled", this.disabled ? `true` : null);
+    this._verifyTabindex();
+  }
+  _handleInput() {
+    if (this.disabled) {
+      return;
+    }
+    this.checked = true;
+    this._uncheckOtherOptions();
+  }
+  _verifyTabindex() {
+    this.tabIndex = this.checked && !this.disabled ? 0 : -1;
+  }
+  render() {
+    return html`
+      <input
+        type="radio"
+        id="sbb-toggle-option-id"
+        aria-hidden="true"
+        tabindex="-1"
+        ?disabled=${this.disabled}
+        .checked=${this.checked || nothing}
+        .value=${this.value || nothing}
+        @click=${(event) => event.stopPropagation()}
+      />
+      <label class="sbb-toggle-option" for="sbb-toggle-option-id">
+        ${this.renderIconSlot()}
+        <span class="sbb-toggle-option__label">
+          <slot></slot>
+        </span>
+      </label>
+    `;
+  }
+};
+SbbToggleOptionElement.styles = style;
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbToggleOptionElement.prototype, "checked", 2);
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbToggleOptionElement.prototype, "disabled", 2);
+__decorateClass([
+  property()
+], SbbToggleOptionElement.prototype, "value", 1);
+SbbToggleOptionElement = __decorateClass([
+  customElement("sbb-toggle-option"),
+  hostAttributes({
+    role: "radio"
+  })
+], SbbToggleOptionElement);
+export {
+  SbbToggleOptionElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"toggle-option.js","sources":["../../../../src/elements/toggle/toggle-option/toggle-option.ts"],"sourcesContent":["import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, LitElement, nothing } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport { SbbConnectedAbortController, SbbSlotStateController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { setOrRemoveAttribute } from '../../core/dom.js';\nimport { SbbIconNameMixin } from '../../icon.js';\nimport type { SbbToggleElement } from '../toggle.js';\n\nimport style from './toggle-option.scss?lit&inline';\n\n/**\n * It displays a toggle option within a `sbb-toggle`.\n *\n * @slot - Use the unnamed slot to add content to the label of the toggle option.\n * @slot icon - Slot used to render the `sbb-icon`.\n */\n@customElement('sbb-toggle-option')\n@hostAttributes({\n  role: 'radio',\n})\nexport class SbbToggleOptionElement extends SbbIconNameMixin(LitElement) {\n  public static override styles: CSSResultGroup = style;\n\n  /** Whether the toggle-option is checked. */\n  @property({ reflect: true, type: Boolean })\n  public checked = false;\n\n  /** Whether the toggle option is disabled. */\n  @property({ reflect: true, type: Boolean })\n  public disabled: boolean = false;\n\n  /** Value of toggle-option. */\n  @property()\n  public set value(value: string) {\n    this._value = `${value}`;\n  }\n  public get value(): string {\n    return this._value;\n  }\n  private _value: string = '';\n\n  private _toggle?: SbbToggleElement;\n  private _abort = new SbbConnectedAbortController(this);\n\n  public constructor() {\n    super();\n    new SbbSlotStateController(this);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    const signal = this._abort.signal;\n\n    // We need to listen input event on host as with keyboard navigation\n    // the Input Event is triggered from sbb-toggle.\n    this.addEventListener('input', () => this._handleInput(), { signal });\n    this.addEventListener('click', () => this.shadowRoot!.querySelector('label')?.click(), {\n      signal,\n    });\n    // We can use closest here, as we expect the parent sbb-toggle to be in light DOM.\n    this._toggle = this.closest?.('sbb-toggle') ?? undefined;\n    this._verifyTabindex();\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('checked')) {\n      this.setAttribute('aria-checked', `${this.checked}`);\n      this._verifyTabindex();\n      if (this.checked) {\n        this._uncheckOtherOptions();\n      }\n    }\n    if (changedProperties.has('disabled')) {\n      this._handleDisabledChange();\n    }\n  }\n\n  private _uncheckOtherOptions(): void {\n    this._toggle?.options.filter((o) => o !== this).forEach((o) => (o.checked = false));\n  }\n\n  private _handleDisabledChange(): void {\n    // Enforce disabled state from parent.\n    if (!this._toggle) {\n      // Ignore illegal state. Our expectation  is that a sbb-toggle-option\n      // always has a parent sbb-toggle.\n    } else if (this._toggle.disabled && !this.disabled) {\n      this.disabled = true;\n    } else if (!this._toggle.disabled && this.disabled) {\n      this.disabled = false;\n    }\n    setOrRemoveAttribute(this, 'aria-disabled', this.disabled ? `true` : null);\n    this._verifyTabindex();\n  }\n\n  private _handleInput(): void {\n    if (this.disabled) {\n      return;\n    }\n    this.checked = true;\n    this._uncheckOtherOptions();\n  }\n\n  private _verifyTabindex(): void {\n    this.tabIndex = this.checked && !this.disabled ? 0 : -1;\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <input\n        type=\"radio\"\n        id=\"sbb-toggle-option-id\"\n        aria-hidden=\"true\"\n        tabindex=\"-1\"\n        ?disabled=${this.disabled}\n        .checked=${this.checked || nothing}\n        .value=${this.value || nothing}\n        @click=${(event: PointerEvent) => event.stopPropagation()}\n      />\n      <label class=\"sbb-toggle-option\" for=\"sbb-toggle-option-id\">\n        ${this.renderIconSlot()}\n        <span class=\"sbb-toggle-option__label\">\n          <slot></slot>\n        </span>\n      </label>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-toggle-option': SbbToggleOptionElement;\n  }\n}\n"],"names":["_a"],"mappings":"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"}

package/development/toggle/toggle.d.ts

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

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

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

package/development/toggle/toggle.js

@@ -0,0 +1,308 @@
+import { css, LitElement, isServer, html } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { interactivityChecker, isArrowKeyPressed, getNextElementIndex } from "../core/a11y.js";
+import { SbbConnectedAbortController } from "../core/controllers.js";
+import { hostAttributes } from "../core/decorators.js";
+import { EventEmitter } from "../core/eventing.js";
+import { AgnosticResizeObserver } 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. */
+*,
+::before,
+::after {
+  box-sizing: border-box;
+}
+
+:host {
+  --sbb-toggle-width: fit-content;
+  --sbb-toggle-min-width: calc(
+    var(--sbb-toggle-padding-inline) * 2 + var(--sbb-size-icon-ui-small)
+  );
+  --sbb-toggle-selected-option-border-color: var(--sbb-color-smoke);
+  --sbb-toggle-padding-inline: var(--sbb-spacing-responsive-xxxs);
+  --sbb-toggle-animation-duration: var(
+    --sbb-disable-animation-zero-time,
+    var(--sbb-animation-duration-6x)
+  );
+  --sbb-toggle-height: 1.75rem;
+  --sbb-toggle-border-width: var(--sbb-border-width-1x);
+  --sbb-toggle-border-style: solid;
+  --sbb-toggle-border-radius: var(--sbb-border-radius-infinity);
+  display: block;
+}
+@media (min-width: calc(52.5rem)) {
+  :host {
+    --sbb-toggle-height: 2rem;
+  }
+}
+@media (forced-colors: active) {
+  :host {
+    --sbb-toggle-selected-option-border-color: Highlight;
+    --sbb-toggle-border-width: var(--sbb-border-width-2x);
+  }
+}
+
+:host([even]) {
+  --sbb-toggle-width: 100%;
+}
+:host([even]) ::slotted(sbb-toggle-option) {
+  width: 50%;
+}
+
+:host([disabled]) {
+  --sbb-toggle-selected-option-border-color: var(--sbb-color-graphite);
+  --sbb-toggle-border-style: dashed;
+}
+@media (forced-colors: active) {
+  :host([disabled]) {
+    --sbb-toggle-border-style: solid;
+    --sbb-toggle-selected-option-border-color: GrayText;
+  }
+}
+
+:host([size=m]) {
+  --sbb-toggle-padding-inline: var(--sbb-spacing-responsive-s);
+  --sbb-toggle-height: 2.75rem;
+}
+@media (min-width: calc(52.5rem)) {
+  :host([size=m]) {
+    --sbb-toggle-height: 3.25rem;
+  }
+}
+
+:host([data-disable-animation-on-resizing]) {
+  --sbb-disable-animation-time: 0.1ms;
+  --sbb-disable-animation-zero-time: 0s;
+}
+
+.sbb-toggle {
+  --sbb-text-font-size: var(--sbb-font-size-text-m);
+  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);
+  position: relative;
+  display: flex;
+  align-items: center;
+  width: var(--sbb-toggle-width);
+  max-width: 100%;
+  min-width: calc(var(--sbb-toggle-min-width) * 2);
+  height: var(--sbb-toggle-height);
+  user-select: none;
+  -webkit-tap-highlight-color: transparent;
+  background: var(--sbb-color-cloud);
+  border-radius: var(--sbb-toggle-border-radius);
+}
+.sbb-toggle::after {
+  content: "";
+  padding-inline: var(--sbb-toggle-padding-inline);
+  display: inline-block;
+  opacity: 1;
+  background-color: var(--sbb-color-white);
+  border: var(--sbb-toggle-border-width) var(--sbb-toggle-border-style) var(--sbb-toggle-selected-option-border-color);
+  border-radius: var(--sbb-toggle-border-radius);
+  position: absolute;
+  max-width: 100%;
+  min-width: var(--sbb-toggle-min-width);
+  inset-block: calc(-2 * var(--sbb-toggle-border-width));
+  inset-inline: calc(var(--sbb-toggle-option-left) - 0.125rem) calc(var(--sbb-toggle-option-right) - 0.125rem);
+  transition-duration: var(--sbb-toggle-animation-duration);
+  transition-timing-function: ease;
+  transition-property: opacity, inset-inline-end, inset-inline-start;
+}
+@media (forced-colors: active) {
+  .sbb-toggle {
+    outline: var(--sbb-toggle-border-width) solid CanvasText;
+  }
+}`;
+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 SbbToggleElement = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this._disabled = false;
+    this.even = false;
+    this.size = "m";
+    this._value = null;
+    this._loaded = false;
+    this._toggleResizeObserver = new AgnosticResizeObserver(
+      () => this._setCheckedPillPosition(true)
+    );
+    this._didChange = new EventEmitter(this, SbbToggleElement.events.didChange, {
+      bubbles: true,
+      composed: true
+    });
+    this._change = new EventEmitter(this, SbbToggleElement.events.change, {
+      bubbles: true,
+      composed: true
+    });
+    this._abort = new SbbConnectedAbortController(this);
+  }
+  set disabled(value) {
+    this._disabled = value;
+    this._updateDisabled();
+  }
+  get disabled() {
+    return this._disabled;
+  }
+  set value(value) {
+    if (isServer) {
+      this._value = value;
+    } else {
+      this._valueChanged(value);
+    }
+  }
+  get value() {
+    var _a, _b;
+    return isServer ? this._value ?? "" : ((_a = this.options.find((o) => o.checked)) == null ? void 0 : _a.value) ?? ((_b = this.options[0]) == null ? void 0 : _b.value) ?? "";
+  }
+  /** The child instances of sbb-toggle-option as an array. */
+  get options() {
+    var _a;
+    return Array.from(((_a = this.querySelectorAll) == null ? void 0 : _a.call(this, "sbb-toggle-option")) ?? []);
+  }
+  _valueChanged(value) {
+    const options = this.options;
+    const selectedOption = options.find(
+      (o) => value === ("value" in o ? o.value : o.getAttribute("value"))
+    ) ?? options.find((o) => o.checked) ?? options[0];
+    if (!selectedOption) {
+      if (!isServer) {
+        console.warn(`sbb-toggle: No available options! (${this.id || "No id"})`);
+      }
+      return;
+    }
+    if (!selectedOption.checked) {
+      selectedOption.checked = true;
+    }
+    this._setCheckedPillPosition(false);
+  }
+  _updateDisabled() {
+    for (const toggleOption of this.options) {
+      toggleOption.disabled = this.disabled;
+    }
+  }
+  _setCheckedPillPosition(resizing) {
+    var _a, _b;
+    if (!this._loaded) {
+      return;
+    }
+    const options = this.options;
+    const toggleElement = this.shadowRoot.querySelector(".sbb-toggle");
+    if (options.every((o) => !o.checked) || options.every((o) => !o.clientWidth) || !toggleElement) {
+      return;
+    }
+    this.toggleAttribute("data-disable-animation-on-resizing", resizing);
+    const firstOption = options[0];
+    const isFirstChecked = firstOption.checked;
+    const pillLeft = firstOption.checked ? "0px" : `${firstOption.clientWidth}px`;
+    const pillRight = isFirstChecked ? `${toggleElement.clientWidth - firstOption.clientWidth}px` : "0px";
+    (_a = this.style) == null ? void 0 : _a.setProperty("--sbb-toggle-option-left", pillLeft);
+    (_b = this.style) == null ? void 0 : _b.setProperty("--sbb-toggle-option-right", pillRight);
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    const signal = this._abort.signal;
+    this.addEventListener("input", () => this._handleInput(), { signal, passive: true });
+    this.addEventListener("keydown", (e) => this._handleKeyDown(e), { signal });
+    this.options.forEach((option) => this._toggleResizeObserver.observe(option));
+    this._updateToggle();
+  }
+  async firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    await this.updateComplete;
+    this._loaded = true;
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._toggleResizeObserver.disconnect();
+  }
+  _updateToggle() {
+    this._valueChanged(this.value);
+    this._updateDisabled();
+  }
+  _handleInput() {
+    this._setCheckedPillPosition(false);
+    this._change.emit();
+    this._didChange.emit();
+  }
+  _handleKeyDown(evt) {
+    const enabledToggleOptions = this.options.filter(
+      (t) => !t.disabled && interactivityChecker.isVisible(t)
+    );
+    if (!enabledToggleOptions || // don't trap nested handling
+    evt.target !== this && evt.target.parentElement !== this) {
+      return;
+    }
+    if (isArrowKeyPressed(evt)) {
+      const checked = enabledToggleOptions.findIndex(
+        (toggleOption) => toggleOption.checked
+      );
+      const nextIndex = getNextElementIndex(evt, checked, enabledToggleOptions.length);
+      if (!enabledToggleOptions[nextIndex].checked) {
+        enabledToggleOptions[nextIndex].checked = true;
+        enabledToggleOptions[nextIndex].focus();
+        enabledToggleOptions[nextIndex].dispatchEvent(
+          new InputEvent("input", { bubbles: true, composed: true })
+        );
+      }
+      evt.preventDefault();
+    }
+  }
+  render() {
+    return html`
+      <div class="sbb-toggle">
+        <slot @slotchange=${this._updateToggle}></slot>
+      </div>
+    `;
+  }
+};
+SbbToggleElement.styles = style;
+SbbToggleElement.events = {
+  didChange: "didChange",
+  change: "change"
+};
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbToggleElement.prototype, "disabled", 1);
+__decorateClass([
+  property({ reflect: true, type: Boolean })
+], SbbToggleElement.prototype, "even", 2);
+__decorateClass([
+  property({ reflect: true })
+], SbbToggleElement.prototype, "size", 2);
+__decorateClass([
+  property()
+], SbbToggleElement.prototype, "value", 1);
+SbbToggleElement = __decorateClass([
+  customElement("sbb-toggle"),
+  hostAttributes({
+    role: "radiogroup"
+  })
+], SbbToggleElement);
+export {
+  SbbToggleElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"toggle.js","sources":["../../../../src/elements/toggle/toggle/toggle.ts"],"sourcesContent":["import {\n  type CSSResultGroup,\n  html,\n  isServer,\n  LitElement,\n  type PropertyValues,\n  type TemplateResult,\n} from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\n\nimport { getNextElementIndex, interactivityChecker, isArrowKeyPressed } from '../../core/a11y.js';\nimport { SbbConnectedAbortController } from '../../core/controllers.js';\nimport { hostAttributes } from '../../core/decorators.js';\nimport { EventEmitter } from '../../core/eventing.js';\nimport { AgnosticResizeObserver } from '../../core/observers.js';\nimport type { SbbToggleOptionElement } from '../toggle-option.js';\n\nimport style from './toggle.scss?lit&inline';\n\n/**\n * It can be used as a container for two `sbb-toggle-option`, acting as a toggle button.\n *\n * @slot - Use the unnamed slot to add `<sbb-toggle-option>` elements to the toggle.\n * @event {CustomEvent<void>} didChange - Deprecated. used for React. Will probably be removed once React 19 is available.\n * @event {CustomEvent<void>} change - Emits whenever the toggle value changes.\n */\n@customElement('sbb-toggle')\n@hostAttributes({\n  role: 'radiogroup',\n})\nexport class SbbToggleElement extends LitElement {\n  public static override styles: CSSResultGroup = style;\n  public static readonly events = {\n    didChange: 'didChange',\n    change: 'change',\n  } as const;\n\n  /** Whether the toggle is disabled. */\n  @property({ reflect: true, type: Boolean })\n  public set disabled(value: boolean) {\n    this._disabled = value;\n    this._updateDisabled();\n  }\n  public get disabled(): boolean {\n    return this._disabled;\n  }\n  private _disabled: boolean = false;\n\n  /**\n   * If true, set the width of the component fixed; if false,\n   * the width is dynamic based on the label of the sbb-toggle-option.\n   */\n  @property({ reflect: true, type: Boolean }) public even: boolean = false;\n\n  /** Size variant, either m or s. */\n  @property({ reflect: true }) public size?: 's' | 'm' = 'm';\n\n  /**\n   * The value of the toggle. It needs to be mutable since it is updated whenever\n   * a new option is selected (see the `onToggleOptionSelect()` method).\n   */\n  @property()\n  public set value(value: string) {\n    if (isServer) {\n      this._value = value;\n    } else {\n      this._valueChanged(value);\n    }\n  }\n  public get value(): string {\n    return isServer\n      ? this._value ?? ''\n      : this.options.find((o) => o.checked)?.value ?? this.options[0]?.value ?? '';\n  }\n  private _value: string | null = null;\n\n  /** The child instances of sbb-toggle-option as an array. */\n  public get options(): SbbToggleOptionElement[] {\n    return Array.from(this.querySelectorAll?.('sbb-toggle-option') ?? []);\n  }\n\n  private _loaded: boolean = false;\n  private _toggleResizeObserver = new AgnosticResizeObserver(() =>\n    this._setCheckedPillPosition(true),\n  );\n\n  private _valueChanged(value: any | undefined): void {\n    const options = this.options;\n    // If options are not yet defined web components, we can check if attribute is already set as a fallback.\n    // We do this by checking whether value property is available (defined component).\n    const selectedOption =\n      options.find(\n        (o) => value === ('value' in o ? o.value : (o as HTMLElement).getAttribute('value')),\n      ) ??\n      options.find((o) => o.checked) ??\n      options[0];\n\n    if (!selectedOption) {\n      if (import.meta.env.DEV && !isServer) {\n        console.warn(`sbb-toggle: No available options! (${this.id || 'No id'})`);\n      }\n      return;\n    }\n    if (!selectedOption.checked) {\n      selectedOption.checked = true;\n    }\n    this._setCheckedPillPosition(false);\n  }\n\n  private _updateDisabled(): void {\n    for (const toggleOption of this.options) {\n      toggleOption.disabled = this.disabled;\n    }\n  }\n\n  /**\n   * @deprecated only used for React. Will probably be removed once React 19 is available.\n   * Emits whenever the toggle value changes.\n   */\n  private _didChange: EventEmitter = new EventEmitter(this, SbbToggleElement.events.didChange, {\n    bubbles: true,\n    composed: true,\n  });\n\n  /** Emits whenever the toggle value changes. */\n  private _change: EventEmitter = new EventEmitter(this, SbbToggleElement.events.change, {\n    bubbles: true,\n    composed: true,\n  });\n\n  private _abort = new SbbConnectedAbortController(this);\n\n  private _setCheckedPillPosition(resizing: boolean): void {\n    if (!this._loaded) {\n      return;\n    }\n\n    const options = this.options;\n    const toggleElement = this.shadowRoot!.querySelector<HTMLDivElement>('.sbb-toggle');\n\n    if (\n      options.every((o) => !o.checked) ||\n      options.every((o) => !o.clientWidth) ||\n      !toggleElement\n    ) {\n      return;\n    }\n\n    this.toggleAttribute('data-disable-animation-on-resizing', resizing);\n\n    const firstOption = options[0];\n    const isFirstChecked = firstOption.checked;\n    const pillLeft = firstOption.checked ? '0px' : `${firstOption.clientWidth}px`;\n    const pillRight = isFirstChecked\n      ? `${toggleElement.clientWidth - firstOption.clientWidth}px`\n      : '0px';\n\n    this.style?.setProperty('--sbb-toggle-option-left', pillLeft);\n    this.style?.setProperty('--sbb-toggle-option-right', pillRight);\n  }\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n    const signal = this._abort.signal;\n    this.addEventListener('input', () => this._handleInput(), { signal, passive: true });\n    this.addEventListener('keydown', (e) => this._handleKeyDown(e), { signal });\n    this.options.forEach((option) => this._toggleResizeObserver.observe(option));\n    this._updateToggle();\n  }\n\n  protected override async firstUpdated(changedProperties: PropertyValues<this>): Promise<void> {\n    super.firstUpdated(changedProperties);\n\n    await this.updateComplete;\n    this._loaded = true;\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._toggleResizeObserver.disconnect();\n  }\n\n  private _updateToggle(): void {\n    this._valueChanged(this.value);\n    this._updateDisabled();\n  }\n\n  private _handleInput(): void {\n    this._setCheckedPillPosition(false);\n    this._change.emit();\n    this._didChange.emit();\n  }\n\n  private _handleKeyDown(evt: KeyboardEvent): void {\n    const enabledToggleOptions = this.options.filter(\n      (t) => !t.disabled && interactivityChecker.isVisible(t),\n    );\n\n    if (\n      !enabledToggleOptions ||\n      // don't trap nested handling\n      ((evt.target as HTMLElement) !== this && (evt.target as HTMLElement).parentElement !== this)\n    ) {\n      return;\n    }\n\n    if (isArrowKeyPressed(evt)) {\n      const checked: number = enabledToggleOptions.findIndex(\n        (toggleOption: SbbToggleOptionElement) => toggleOption.checked,\n      );\n      const nextIndex: number = getNextElementIndex(evt, checked, enabledToggleOptions.length);\n      if (!enabledToggleOptions[nextIndex].checked) {\n        enabledToggleOptions[nextIndex].checked = true;\n        enabledToggleOptions[nextIndex].focus();\n        enabledToggleOptions[nextIndex].dispatchEvent(\n          new InputEvent('input', { bubbles: true, composed: true }),\n        );\n      }\n      evt.preventDefault();\n    }\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-toggle\">\n        <slot @slotchange=${this._updateToggle}></slot>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-toggle': SbbToggleElement;\n  }\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,34 @@
+import { CSSResultGroup, PropertyValues, TemplateResult, LitElement } from 'lit';
+
+declare const SbbToggleCheckElement_base: import('../core/mixins.js').Constructor<import('../core/mixins.js').SbbFormAssociatedCheckboxMixinType> & import('../core/mixins.js').AbstractConstructor<import('../icon.js').SbbIconNameMixinType> & typeof LitElement;
+/**
+ * It displays a toggle checkbox.
+ *
+ * @slot - Use the unnamed slot to add content to the toggle label.
+ * @slot icon - Use this slot to provide an icon. If `icon-name` is set, a sbb-icon will be used.
+ * @event {CustomEvent<void>} didChange - Deprecated. used for React. Will probably be removed once React 19 is available.
+ * @event {Event} change - Event fired on change.
+ * @event {InputEvent} input - Event fired on input.
+ */
+export declare class SbbToggleCheckElement extends SbbToggleCheckElement_base {
+    static styles: CSSResultGroup;
+    static readonly events: {
+        readonly didChange: "didChange";
+    };
+    /** Size variant, either m or s. */
+    size: 's' | 'm';
+    /** The svg name for the true state - default -> 'tick-small' */
+    iconName: string;
+    /** The label position relative to the toggle. Defaults to 'after' */
+    labelPosition?: 'before' | 'after';
+    constructor();
+    protected willUpdate(changedProperties: PropertyValues<this>): Promise<void>;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-toggle-check': SbbToggleCheckElement;
+    }
+}
+export {};
+//# sourceMappingURL=toggle-check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toggle-check.d.ts","sourceRoot":"","sources":["../../../../src/elements/toggle-check/toggle-check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1E,OAAO,EAAQ,UAAU,EAAE,MAAM,KAAK,CAAC;;AASvC;;;;;;;;GAQG;AACH,qBACa,qBAAsB,SAAQ,0BAE1C;IACC,OAAuB,MAAM,EAAE,cAAc,CAAS;IACtD,gBAAuB,MAAM;;MAElB;IAEX,mCAAmC;IACC,IAAI,EAAE,GAAG,GAAG,GAAG,CAAO;IAE1D,gEAAgE;IACV,QAAQ,SAAgB;IAE9E,qEAAqE;IAE9D,aAAa,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAW;;cAO3B,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;cASxE,MAAM,IAAI,cAAc;CAgB5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,kBAAkB,EAAE,qBAAqB,CAAC;KAC3C;CACF"}

package/development/toggle-check.d.ts

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

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

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