@solid-design-system/components 3.23.4 → 4.0.0-next.0

package/dist-versioned/chunks/chunk.ZGPGFEVP.js

@@ -0,0 +1,221 @@
+import {
+  getAnimation,
+  setDefaultAnimation
+} from "./chunk.N4LHE3QK.js";
+import {
+  animateTo,
+  stopAnimations
+} from "./chunk.EY4JPJJQ.js";
+import {
+  waitForEvent
+} from "./chunk.B4BZKR24.js";
+import {
+  watch
+} from "./chunk.X2OQMWGY.js";
+import {
+  LocalizeController
+} from "./chunk.YKM42GKF.js";
+import {
+  SolidElement,
+  customElement
+} from "./chunk.UDZYWRPT.js";
+import {
+  __decorateClass
+} from "./chunk.S3NI7NKU.js";
+
+// src/components/notification/notification.ts
+import { css, html } from "lit";
+import { property, query } from "lit/decorators.js";
+import cx from "classix";
+var toastStackDefault = Object.assign(document.createElement("div"), {
+  className: "sd-toast-stack sd-toast-stack--top-right"
+});
+var toastStackBottomCenter = Object.assign(document.createElement("div"), {
+  className: "sd-toast-stack sd-toast-stack--bottom-center"
+});
+var SdNotification = class extends SolidElement {
+  constructor() {
+    super(...arguments);
+    this.localize = new LocalizeController(this);
+    this.variant = "info";
+    this.open = false;
+    this.closable = false;
+    this.duration = Infinity;
+    this.durationIndicator = false;
+    this.toastStack = "top-right";
+    this.remainingDuration = this.duration;
+    this.startTime = Date.now();
+  }
+  firstUpdated() {
+    this.base.hidden = !this.open;
+  }
+  startAutoHide() {
+    clearTimeout(this.autoHideTimeout);
+    this.startTime = Date.now();
+    this.remainingDuration = this.duration;
+    if (this.open && this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(() => this.hide(), this.duration);
+    }
+  }
+  onHover() {
+    clearTimeout(this.autoHideTimeout);
+    if (this.duration < Infinity) {
+      this.remainingDuration -= Date.now() - this.startTime;
+    }
+  }
+  onHoverEnd() {
+    this.startTime = Date.now();
+    clearTimeout(this.autoHideTimeout);
+    if (this.open && this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(() => {
+        this.hide();
+      }, this.remainingDuration);
+    }
+  }
+  handleCloseClick() {
+    this.hide();
+  }
+  async handleOpenChange() {
+    if (this.open) {
+      this.emit("sd-show");
+      if (this.duration < Infinity) {
+        this.startAutoHide();
+      }
+      await stopAnimations(this.base);
+      this.base.hidden = false;
+      const { keyframes, options } = getAnimation(this, "notification.show", { dir: this.localize.dir() });
+      await animateTo(this.base, keyframes, options);
+      this.emit("sd-after-show");
+    } else {
+      this.emit("sd-hide");
+      clearTimeout(this.autoHideTimeout);
+      await stopAnimations(this.base);
+      const { keyframes, options } = getAnimation(this, "notification.hide", { dir: this.localize.dir() });
+      await animateTo(this.base, keyframes, options);
+      this.base.hidden = true;
+      this.emit("sd-after-hide");
+    }
+  }
+  handleDurationChange() {
+    this.startAutoHide();
+  }
+  /** Shows the notification. */
+  async show() {
+    if (this.open) {
+      return void 0;
+    }
+    this.open = true;
+    return waitForEvent(this, "sd-after-show");
+  }
+  /** Hides the notification */
+  async hide() {
+    if (!this.open) {
+      return void 0;
+    }
+    this.open = false;
+    return waitForEvent(this, "sd-after-hide");
+  }
+  /**
+   * Displays the notification as a toast notification. This will move the notification out of its position in the DOM and, when
+   * dismissed, it will be removed from the DOM completely. By storing a reference to the notification, you can reuse it by
+   * calling this method again. The returned promise will resolve after the notification is hidden.
+   */
+  async toast() {
+    return new Promise((resolve) => {
+      const toastStack = this.toastStack === "bottom-center" ? toastStackBottomCenter : toastStackDefault;
+      if (toastStack.parentElement === null) {
+        document.body.append(toastStack);
+      }
+      toastStack.appendChild(this);
+      requestAnimationFrame(() => {
+        this.clientWidth;
+        this.show();
+      });
+      this.addEventListener(
+        "sd-after-hide",
+        () => {
+          toastStack.removeChild(this);
+          resolve();
+          if (toastStack.querySelector("sd-4-0-0-next-0-notification") === null) {
+            toastStack.remove();
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+  render() {
+    return html`<div part="base" class="${cx("w-full overflow-hidden flex items-stretch relative m-2")}" role="alert" id="notification" aria-hidden="${this.open ? "false" : "true"}" @mouseenter="${this.onHover}" @mouseleave="${this.onHoverEnd}"><slot name="icon" part="icon" class="${cx(
+      "min-w-min flex items-center px-3 justify-center",
+      {
+        info: "bg-info",
+        success: "bg-success",
+        warning: "bg-warning",
+        error: "bg-error"
+      }[this.variant]
+    )}"><sd-4-0-0-next-0-icon name="${{
+      info: "info-circle",
+      success: "confirm-circle",
+      warning: "exclamation-circle",
+      error: "warning"
+    }[this.variant] || ""}" library="system" class="h-6 w-6 text-white"></sd-4-0-0-next-0-icon></slot><div part="content" class="${cx(
+      "h-full w-full p-1 gap-2 flex items-center justify-stretch bg-white",
+      "border-solid border-[1px] border-l-0 border-neutral-400"
+    )}"><slot part="message" class="block w-full pl-3 py-2" aria-live="polite"></slot>${this.closable ? html`<sd-4-0-0-next-0-button size="md" variant="tertiary" part="close-button" class="ml-auto flex flex-[0_0_auto] items-stretch" @click="${this.handleCloseClick}"><sd-4-0-0-next-0-icon label="${this.localize.term("close")}" name="close" library="system" color="currentColor"></sd-4-0-0-next-0-icon></sd-4-0-0-next-0-button>` : ""}</div>${this.durationIndicator ? html`<div part="duration-indicator__elapsed" id="duration-indicator__elapsed" style="${`animation-duration: ${this.duration}ms`}" class="${cx(`absolute w-0 h-[2px] bottom-0 bg-primary z-10 animate-grow`)}"></div><div part="duration-indicator__total" class="w-full h-[2px] bottom-0 absolute border border-neutral-400"></div>` : ""}</div>`;
+  }
+};
+/**
+ * Inherits global stylesheet including TailwindCSS
+ */
+SdNotification.styles = [
+  ...SolidElement.styles,
+  css`:host{display:contents}#notification:hover #duration-indicator__elapsed{animation-play-state:paused!important}`
+];
+__decorateClass([
+  query('[part~="base"]')
+], SdNotification.prototype, "base", 2);
+__decorateClass([
+  property({ reflect: true })
+], SdNotification.prototype, "variant", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], SdNotification.prototype, "open", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], SdNotification.prototype, "closable", 2);
+__decorateClass([
+  property({ type: Number })
+], SdNotification.prototype, "duration", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true, attribute: "duration-indicator" })
+], SdNotification.prototype, "durationIndicator", 2);
+__decorateClass([
+  property({ reflect: true, attribute: "toast-stack" })
+], SdNotification.prototype, "toastStack", 2);
+__decorateClass([
+  watch("open", { waitUntilFirstUpdate: true })
+], SdNotification.prototype, "handleOpenChange", 1);
+__decorateClass([
+  watch("duration")
+], SdNotification.prototype, "handleDurationChange", 1);
+SdNotification = __decorateClass([
+  customElement("sd-4-0-0-next-0-notification")
+], SdNotification);
+setDefaultAnimation("notification.show", {
+  keyframes: [
+    { opacity: 0, scale: 0.8 },
+    { opacity: 1, scale: 1 }
+  ],
+  options: { duration: 250, easing: "ease" }
+});
+setDefaultAnimation("notification.hide", {
+  keyframes: [
+    { opacity: 1, scale: 1 },
+    { opacity: 0, scale: 0.8 }
+  ],
+  options: { duration: 250, easing: "ease" }
+});
+
+export {
+  SdNotification
+};

package/dist-versioned/chunks/chunk.ZWJI7SLE.js

@@ -0,0 +1,76 @@
+import {
+  SolidElement,
+  customElement
+} from "./chunk.UDZYWRPT.js";
+import {
+  __decorateClass
+} from "./chunk.S3NI7NKU.js";
+
+// src/components/button-group/button-group.ts
+import { css, html } from "lit";
+import { property, query, state } from "lit/decorators.js";
+var SdButtonGroup = class extends SolidElement {
+  constructor() {
+    super(...arguments);
+    this.disableRole = false;
+    this.label = "";
+  }
+  handleFocus(event) {
+    const button = findButton(event.target);
+    button == null ? void 0 : button.classList.add("sd-4-0-0-next-0-button-group__button--focus");
+  }
+  handleBlur(event) {
+    const button = findButton(event.target);
+    button == null ? void 0 : button.classList.remove("sd-4-0-0-next-0-button-group__button--focus");
+  }
+  handleMouseOver(event) {
+    const button = findButton(event.target);
+    button == null ? void 0 : button.classList.add("sd-4-0-0-next-0-button-group__button--hover");
+  }
+  handleMouseOut(event) {
+    const button = findButton(event.target);
+    button == null ? void 0 : button.classList.remove("sd-4-0-0-next-0-button-group__button--hover");
+  }
+  handleSlotChange() {
+    const slottedElements = [...this.defaultSlot.assignedElements({ flatten: true })];
+    slottedElements.forEach((el) => {
+      const index = slottedElements.indexOf(el);
+      const button = findButton(el);
+      if (button !== null) {
+        button.classList.add("sd-4-0-0-next-0-button-group__button");
+        button.classList.toggle("sd-4-0-0-next-0-button-group__button--first", index === 0);
+        button.classList.toggle("sd-4-0-0-next-0-button-group__button--inner", index > 0 && index < slottedElements.length - 1);
+        button.classList.toggle("sd-4-0-0-next-0-button-group__button--last", index === slottedElements.length - 1);
+        button.classList.toggle("sd-4-0-0-next-0-button-group__button--radio", button.tagName.toLowerCase() === "sd-4-0-0-next-0-radio-button");
+      }
+    });
+  }
+  render() {
+    return html`<slot part="base" role="${this.disableRole ? "presentation" : "group"}" aria-label="${this.label}" @focusout="${this.handleBlur}" @focusin="${this.handleFocus}" @mouseover="${this.handleMouseOver}" @mouseout="${this.handleMouseOut}" @slotchange="${this.handleSlotChange}"></slot>`;
+  }
+};
+SdButtonGroup.styles = [
+  ...SolidElement.styles,
+  css`:host{display:inline-block}[part=base]{display:flex;flex-wrap:nowrap}`
+];
+__decorateClass([
+  query("slot")
+], SdButtonGroup.prototype, "defaultSlot", 2);
+__decorateClass([
+  state()
+], SdButtonGroup.prototype, "disableRole", 2);
+__decorateClass([
+  property()
+], SdButtonGroup.prototype, "label", 2);
+SdButtonGroup = __decorateClass([
+  customElement("sd-4-0-0-next-0-button-group")
+], SdButtonGroup);
+function findButton(el) {
+  var _a;
+  const selector = "sd-4-0-0-next-0-button, sd-4-0-0-next-0-radio-button";
+  return (_a = el.closest(selector)) != null ? _a : el.querySelector(selector);
+}
+
+export {
+  SdButtonGroup
+};

package/dist-versioned/components/accordion/accordion.d.ts

@@ -0,0 +1,24 @@
+import '../icon/icon';
+import { LocalizeController } from '../../utilities/localize';
+import SolidElement from '../../internal/solid-element';
+export default class SdAccordion extends SolidElement {
+    localize: LocalizeController;
+    accordion: HTMLElement;
+    header: HTMLElement;
+    body: HTMLElement;
+    open: boolean;
+    summary: string;
+    firstUpdated(): void;
+    protected handleSummaryClick(): void;
+    protected handleSummaryKeyDown(event: KeyboardEvent): void;
+    handleOpenChange(): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    render(): import("lit").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sd-4-0-0-next-0-accordion': SdAccordion;
+    }
+}

package/dist-versioned/components/accordion/accordion.js

@@ -0,0 +1,21 @@
+import {
+  SdAccordion
+} from "../../chunks/chunk.DAM3ICHP.js";
+import "../../chunks/chunk.N4LHE3QK.js";
+import "../../chunks/chunk.3IT4HBTI.js";
+import "../../chunks/chunk.P52GZVKG.js";
+import "../../chunks/chunk.RPB53XXV.js";
+import "../../chunks/chunk.JCK5DTZN.js";
+import "../../chunks/chunk.7VPFFNHR.js";
+import "../../chunks/chunk.XS4QJO4N.js";
+import "../../chunks/chunk.EY4JPJJQ.js";
+import "../../chunks/chunk.B4BZKR24.js";
+import "../../chunks/chunk.X2OQMWGY.js";
+import "../../chunks/chunk.YKM42GKF.js";
+import "../../chunks/chunk.MNYQWRJE.js";
+import "../../chunks/chunk.2S2CNWKY.js";
+import "../../chunks/chunk.UDZYWRPT.js";
+import "../../chunks/chunk.S3NI7NKU.js";
+export {
+  SdAccordion as default
+};

package/dist-versioned/components/accordion-group/accordion-group.d.ts

@@ -0,0 +1,16 @@
+import '../accordion/accordion';
+import SolidElement from '../../internal/solid-element';
+export default class SdAccordionGroup extends SolidElement {
+    _accordionsInDefaultSlot: HTMLElement[];
+    closeOthers: boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleAccordionShow;
+    render(): import("lit").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sd-4-0-0-next-0-accordion-group': SdAccordionGroup;
+    }
+}

package/dist-versioned/components/accordion-group/accordion-group.js

@@ -0,0 +1,22 @@
+import {
+  SdAccordionGroup
+} from "../../chunks/chunk.IN3GJ5QL.js";
+import "../../chunks/chunk.DAM3ICHP.js";
+import "../../chunks/chunk.N4LHE3QK.js";
+import "../../chunks/chunk.3IT4HBTI.js";
+import "../../chunks/chunk.P52GZVKG.js";
+import "../../chunks/chunk.RPB53XXV.js";
+import "../../chunks/chunk.JCK5DTZN.js";
+import "../../chunks/chunk.7VPFFNHR.js";
+import "../../chunks/chunk.XS4QJO4N.js";
+import "../../chunks/chunk.EY4JPJJQ.js";
+import "../../chunks/chunk.B4BZKR24.js";
+import "../../chunks/chunk.X2OQMWGY.js";
+import "../../chunks/chunk.YKM42GKF.js";
+import "../../chunks/chunk.MNYQWRJE.js";
+import "../../chunks/chunk.2S2CNWKY.js";
+import "../../chunks/chunk.UDZYWRPT.js";
+import "../../chunks/chunk.S3NI7NKU.js";
+export {
+  SdAccordionGroup as default
+};

package/dist-versioned/components/animation/animation.d.ts

@@ -0,0 +1,39 @@
+import SolidElement from '../../internal/solid-element';
+export default class SdAnimation extends SolidElement {
+    private animation?;
+    private hasStarted;
+    defaultSlot: Promise<HTMLSlotElement>;
+    name: string;
+    play: boolean;
+    delay: number;
+    direction: PlaybackDirection;
+    duration: number;
+    easing: string;
+    endDelay: number;
+    fill: FillMode;
+    iterations: number;
+    iterationStart: number;
+    keyframes?: Keyframe[];
+    playbackRate: number;
+    get currentTime(): number;
+    set currentTime(time: number);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleAnimationFinish;
+    private handleAnimationCancel;
+    private handleSlotChange;
+    private createAnimation;
+    private destroyAnimation;
+    handleAnimationChange(): void;
+    handlePlayChange(): boolean;
+    handlePlaybackRateChange(): void;
+    cancel(): void;
+    finish(): void;
+    render(): import("lit").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sd-4-0-0-next-0-animation': SdAnimation;
+    }
+}

package/dist-versioned/components/animation/animation.js

@@ -0,0 +1,10 @@
+import {
+  SdAnimation
+} from "../../chunks/chunk.UC5E3AEF.js";
+import "../../chunks/chunk.X2OQMWGY.js";
+import "../../chunks/chunk.TJOP7HQP.js";
+import "../../chunks/chunk.UDZYWRPT.js";
+import "../../chunks/chunk.S3NI7NKU.js";
+export {
+  SdAnimation as default
+};

package/dist-versioned/components/animation/animations.d.ts

@@ -0,0 +1,4 @@
+import * as animations from '@shoelace-style/animations';
+export { animations };
+export declare function getAnimationNames(): string[];
+export declare function getEasingNames(): string[];

package/dist-versioned/components/animation/animations.js

@@ -0,0 +1,11 @@
+import {
+  animations,
+  getAnimationNames,
+  getEasingNames
+} from "../../chunks/chunk.TJOP7HQP.js";
+import "../../chunks/chunk.S3NI7NKU.js";
+export {
+  animations,
+  getAnimationNames,
+  getEasingNames
+};

package/dist-versioned/components/audio/audio.d.ts

@@ -0,0 +1,55 @@
+import { Wave } from './wave';
+import SolidElement from '../../internal/solid-element';
+import type SdDrawer from '../drawer/drawer';
+export default class SdAudio extends SolidElement {
+    private readonly localize;
+    private readonly hasSlotController;
+    reversedLayout: boolean;
+    hideTimestamps: boolean;
+    animated: boolean;
+    inverted: boolean;
+    speed: number;
+    currentTime: string;
+    duration: string;
+    isPlaying: boolean;
+    isMuted: boolean;
+    progress: number;
+    progressSlider: HTMLInputElement;
+    audioPlayerContainer: HTMLElement;
+    drawer: SdDrawer;
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    waveList: Wave[];
+    constructor();
+    firstUpdated(): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    private get audioElement();
+    private setAudioProgress;
+    private updateCurrentTime;
+    private updateAudioDuration;
+    playAudio(): void;
+    pauseAudio(): void;
+    handleAudioEnd(): void;
+    private toggleMute;
+    private toggleMuteKeydown;
+    togglePlaybackSpeed(): void;
+    private togglePlaybackSpeedKeydown;
+    private formatTime;
+    private handleAudioProgress;
+    private handleAudioProgressKeydown;
+    private showTranscript;
+    private showTranscriptKeydown;
+    private rgbToHex;
+    private initAnimation;
+    private drawStillWaves;
+    private stopAnimation;
+    private clear;
+    draw(): Promise<void>;
+    render(): import("lit").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sd-4-0-0-next-0-audio': SdAudio;
+    }
+}

package/dist-versioned/components/audio/audio.js

@@ -0,0 +1,13 @@
+import {
+  SdAudio
+} from "../../chunks/chunk.QAZYUCBK.js";
+import "../../chunks/chunk.YEZS5ZR2.js";
+import "../../chunks/chunk.YKM42GKF.js";
+import "../../chunks/chunk.MNYQWRJE.js";
+import "../../chunks/chunk.2S2CNWKY.js";
+import "../../chunks/chunk.UDZYWRPT.js";
+import "../../chunks/chunk.POFWU6ZT.js";
+import "../../chunks/chunk.S3NI7NKU.js";
+export {
+  SdAudio as default
+};

package/dist-versioned/components/audio/base64Audio.d.ts

@@ -0,0 +1,2 @@
+declare const base64Audio = "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";
+export default base64Audio;