@kdcloudjs/shoelace 1.0.43 → 1.0.45

package/dist/chunks/chunk.EKXPMPO2.js

@@ -0,0 +1,24 @@
+import {
+  SlTag
+} from "./chunk.HNBV77LW.js";
+
+// src/react/tag/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-tag";
+SlTag.define("sl-tag");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlTag,
+  react: React,
+  events: {
+    onSlRemove: "sl-remove"
+  },
+  displayName: "SlTag"
+});
+var tag_default = reactWrapper;
+
+export {
+  tag_default
+};

package/dist/chunks/chunk.EV7OI2WV.js

@@ -0,0 +1,11 @@
+import {
+  SlVisuallyHidden
+} from "./chunk.QSXPROE6.js";
+
+// src/components/visually-hidden/visually-hidden.ts
+var visually_hidden_default = SlVisuallyHidden;
+SlVisuallyHidden.define("sl-visually-hidden");
+
+export {
+  visually_hidden_default
+};

package/dist/chunks/chunk.EWTYDN6H.js

@@ -0,0 +1,11 @@
+import {
+  SlTree
+} from "./chunk.QPO4SZUB.js";
+
+// src/components/tree/tree.ts
+var tree_default = SlTree;
+SlTree.define("sl-tree");
+
+export {
+  tree_default
+};

package/dist/chunks/chunk.FF3CGXMY.js

@@ -0,0 +1,25 @@
+import {
+  SlIconButton
+} from "./chunk.KTEDC3LM.js";
+
+// src/react/icon-button/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-icon-button";
+SlIconButton.define("sl-icon-button");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlIconButton,
+  react: React,
+  events: {
+    onSlBlur: "sl-blur",
+    onSlFocus: "sl-focus"
+  },
+  displayName: "SlIconButton"
+});
+var icon_button_default = reactWrapper;
+
+export {
+  icon_button_default
+};

package/dist/chunks/chunk.FFPZDSCN.js

@@ -0,0 +1,27 @@
+import {
+  SlDatePanel
+} from "./chunk.7HWPRW4Q.js";
+
+// src/react/date-panel/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-date-panel";
+SlDatePanel.define("sl-date-panel");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlDatePanel,
+  react: React,
+  events: {
+    onSlCancel: "sl-cancel",
+    onSlClear: "sl-clear",
+    onSlConfirm: "sl-confirm",
+    onSlDateChange: "sl-date-change"
+  },
+  displayName: "SlDatePanel"
+});
+var date_panel_default = reactWrapper;
+
+export {
+  date_panel_default
+};

package/dist/chunks/chunk.FHXI54IP.js

@@ -0,0 +1,286 @@
+import {
+  blurActiveElement
+} from "./chunk.LD4M4QGE.js";
+import {
+  getAnimation,
+  setDefaultAnimation
+} from "./chunk.WO7ALQNH.js";
+import {
+  waitForEvent
+} from "./chunk.B4BZKR24.js";
+import {
+  animateTo,
+  stopAnimations
+} from "./chunk.VHWATTYS.js";
+import {
+  SlIconButton
+} from "./chunk.KTEDC3LM.js";
+import {
+  LocalizeController
+} from "./chunk.6CTB5ZDJ.js";
+import {
+  HasSlotController
+} from "./chunk.NYIIDP5N.js";
+import {
+  alert_styles_default
+} from "./chunk.KR7NQXTO.js";
+import {
+  watch
+} from "./chunk.55S3OOTM.js";
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+import {
+  ShoelaceElement
+} from "./chunk.ZFM37KIH.js";
+import {
+  __decorateClass
+} from "./chunk.W5KB6T3Z.js";
+
+// src/components/alert/alert.component.ts
+import { classMap } from "lit/directives/class-map.js";
+import { html } from "lit";
+import { property, query, state } from "lit/decorators.js";
+var _SlAlert = class _SlAlert extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.hasSlotController = new HasSlotController(this, "icon", "suffix");
+    this.localize = new LocalizeController(this);
+    this.open = false;
+    this.closable = false;
+    this.variant = "primary";
+    this.duration = Infinity;
+    this.remainingTime = this.duration;
+  }
+  static get toastStack() {
+    if (!this.currentToastStack) {
+      this.currentToastStack = Object.assign(document.createElement("div"), {
+        className: "sl-toast-stack"
+      });
+    }
+    return this.currentToastStack;
+  }
+  firstUpdated() {
+    this.base.hidden = !this.open;
+  }
+  restartAutoHide() {
+    this.handleCountdownChange();
+    clearTimeout(this.autoHideTimeout);
+    clearInterval(this.remainingTimeInterval);
+    if (this.open && this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(() => this.hide(), this.duration);
+      this.remainingTime = this.duration;
+      this.remainingTimeInterval = window.setInterval(() => {
+        this.remainingTime -= 100;
+      }, 100);
+    }
+  }
+  pauseAutoHide() {
+    var _a;
+    (_a = this.countdownAnimation) == null ? void 0 : _a.pause();
+    clearTimeout(this.autoHideTimeout);
+    clearInterval(this.remainingTimeInterval);
+  }
+  resumeAutoHide() {
+    var _a;
+    if (this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(() => this.hide(), this.remainingTime);
+      this.remainingTimeInterval = window.setInterval(() => {
+        this.remainingTime -= 100;
+      }, 100);
+      (_a = this.countdownAnimation) == null ? void 0 : _a.play();
+    }
+  }
+  handleCountdownChange() {
+    if (this.open && this.duration < Infinity && this.countdown) {
+      const { countdownElement } = this;
+      const start = "100%";
+      const end = "0";
+      this.countdownAnimation = countdownElement.animate([{ width: start }, { width: end }], {
+        duration: this.duration,
+        easing: "linear"
+      });
+    }
+  }
+  handleCloseClick() {
+    this.hide();
+  }
+  async handleOpenChange() {
+    if (this.open) {
+      this.emit("sl-show");
+      if (this.duration < Infinity) {
+        this.restartAutoHide();
+      }
+      await stopAnimations(this.base);
+      this.base.hidden = false;
+      const { keyframes, options } = getAnimation(this, "alert.show", { dir: this.localize.dir() });
+      await animateTo(this.base, keyframes, options);
+      this.emit("sl-after-show");
+    } else {
+      blurActiveElement(this);
+      this.emit("sl-hide");
+      clearTimeout(this.autoHideTimeout);
+      clearInterval(this.remainingTimeInterval);
+      await stopAnimations(this.base);
+      const { keyframes, options } = getAnimation(this, "alert.hide", { dir: this.localize.dir() });
+      await animateTo(this.base, keyframes, options);
+      this.base.hidden = true;
+      this.emit("sl-after-hide");
+    }
+  }
+  handleDurationChange() {
+    this.restartAutoHide();
+  }
+  /** Shows the alert. */
+  async show() {
+    if (this.open) {
+      return void 0;
+    }
+    this.open = true;
+    return waitForEvent(this, "sl-after-show");
+  }
+  /** Hides the alert */
+  async hide() {
+    if (!this.open) {
+      return void 0;
+    }
+    this.open = false;
+    return waitForEvent(this, "sl-after-hide");
+  }
+  /**
+   * Displays the alert as a toast notification. This will move the alert out of its position in the DOM and, when
+   * dismissed, it will be removed from the DOM completely. By storing a reference to the alert, you can reuse it by
+   * calling this method again. The returned promise will resolve after the alert is hidden.
+   */
+  async toast() {
+    return new Promise((resolve) => {
+      this.handleCountdownChange();
+      if (_SlAlert.toastStack.parentElement === null) {
+        document.body.append(_SlAlert.toastStack);
+      }
+      _SlAlert.toastStack.appendChild(this);
+      requestAnimationFrame(() => {
+        this.clientWidth;
+        this.show();
+      });
+      this.addEventListener(
+        "sl-after-hide",
+        () => {
+          _SlAlert.toastStack.removeChild(this);
+          resolve();
+          if (_SlAlert.toastStack.querySelector("sl-alert") === null) {
+            _SlAlert.toastStack.remove();
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+  render() {
+    return html`
+      <div
+        part="base"
+        class=${classMap({
+      alert: true,
+      "alert--open": this.open,
+      "alert--closable": this.closable,
+      "alert--has-countdown": !!this.countdown,
+      "alert--has-icon": this.hasSlotController.test("icon"),
+      "alert--primary": this.variant === "primary",
+      "alert--success": this.variant === "success",
+      "alert--neutral": this.variant === "neutral",
+      "alert--warning": this.variant === "warning",
+      "alert--danger": this.variant === "danger"
+    })}
+        role="alert"
+        aria-hidden=${this.open ? "false" : "true"}
+        @mouseenter=${this.pauseAutoHide}
+        @mouseleave=${this.resumeAutoHide}
+      >
+        <div part="icon" class="alert__icon">
+          <slot name="icon"></slot>
+        </div>
+
+        <div part="message" class="alert__message" aria-live="polite">
+          <slot></slot>
+        </div>
+
+        ${this.closable ? html`
+              <sl-icon-button
+                part="close-button"
+                exportparts="base:close-button__base"
+                class="alert__close-button"
+                name="x-lg"
+                library="system"
+                label=${this.localize.term("close")}
+                @click=${this.handleCloseClick}
+              ></sl-icon-button>
+            ` : ""}
+
+        <div role="timer" class="alert__timer">${this.remainingTime}</div>
+
+        ${this.countdown ? html`
+              <div
+                class=${classMap({
+      alert__countdown: true,
+      "alert__countdown--ltr": this.countdown === "ltr"
+    })}
+              >
+                <div class="alert__countdown-elapsed"></div>
+              </div>
+            ` : ""}
+      </div>
+    `;
+  }
+};
+_SlAlert.styles = [component_styles_default, alert_styles_default];
+_SlAlert.dependencies = { "sl-icon-button": SlIconButton };
+__decorateClass([
+  query('[part~="base"]')
+], _SlAlert.prototype, "base", 2);
+__decorateClass([
+  query(".alert__countdown-elapsed")
+], _SlAlert.prototype, "countdownElement", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], _SlAlert.prototype, "open", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], _SlAlert.prototype, "closable", 2);
+__decorateClass([
+  property({ reflect: true })
+], _SlAlert.prototype, "variant", 2);
+__decorateClass([
+  property({ type: Number })
+], _SlAlert.prototype, "duration", 2);
+__decorateClass([
+  property({ type: String, reflect: true })
+], _SlAlert.prototype, "countdown", 2);
+__decorateClass([
+  state()
+], _SlAlert.prototype, "remainingTime", 2);
+__decorateClass([
+  watch("open", { waitUntilFirstUpdate: true })
+], _SlAlert.prototype, "handleOpenChange", 1);
+__decorateClass([
+  watch("duration")
+], _SlAlert.prototype, "handleDurationChange", 1);
+var SlAlert = _SlAlert;
+setDefaultAnimation("alert.show", {
+  keyframes: [
+    { opacity: 0, scale: 0.8 },
+    { opacity: 1, scale: 1 }
+  ],
+  options: { duration: 250, easing: "ease" }
+});
+setDefaultAnimation("alert.hide", {
+  keyframes: [
+    { opacity: 1, scale: 1 },
+    { opacity: 0, scale: 0.8 }
+  ],
+  options: { duration: 250, easing: "ease" }
+});
+
+export {
+  SlAlert
+};

package/dist/chunks/chunk.FKZTQOEP.js

@@ -0,0 +1,191 @@
+import {
+  segmented_styles_default
+} from "./chunk.C46PSYHF.js";
+import {
+  SlTooltip
+} from "./chunk.3DEPNMW6.js";
+import {
+  SlIcon
+} from "./chunk.H3VTQBCH.js";
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+import {
+  ShoelaceElement
+} from "./chunk.ZFM37KIH.js";
+import {
+  __decorateClass,
+  __spreadProps,
+  __spreadValues
+} from "./chunk.W5KB6T3Z.js";
+
+// src/components/segmented/segmented.component.ts
+import { html, nothing } from "lit";
+import { property, state, query, queryAll } from "lit/decorators.js";
+var SlSegmented = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.options = [];
+    this.disabled = false;
+    this.orientation = "horizontal";
+    this.shape = "default";
+    this.size = "medium";
+    this.block = false;
+    this.name = "segmented";
+    this.thumbStyle = "";
+    this._internalValue = "";
+  }
+  /** 判断是否为受控模式 */
+  get isControlled() {
+    return this.value !== void 0;
+  }
+  /** 获取当前选中值（受控模式用 value，非受控模式用内部值） */
+  get currentValue() {
+    return this.isControlled ? this.value : this._internalValue;
+  }
+  normalizeOption(opt) {
+    var _a;
+    if (typeof opt === "string") return { label: opt, value: opt };
+    if (typeof opt === "number") return { label: String(opt), value: opt };
+    return __spreadProps(__spreadValues({}, opt), { label: (_a = opt.label) != null ? _a : "" });
+  }
+  get normalizedOptions() {
+    return this.options.map((o) => this.normalizeOption(o));
+  }
+  handleChange(opt) {
+    var _a;
+    if (this.disabled || opt.disabled) return;
+    if (opt.value === this.currentValue) return;
+    if (!this.isControlled) {
+      this._internalValue = opt.value;
+    }
+    (_a = this.onChange) == null ? void 0 : _a.call(this, opt.value);
+    if (this.isControlled) {
+      this.requestUpdate();
+    }
+    this.updateComplete.then(() => this.updateThumb());
+  }
+  updateThumb() {
+    var _a;
+    if (!this.container || !((_a = this.itemEls) == null ? void 0 : _a.length)) return;
+    const opts = this.normalizedOptions;
+    const idx = opts.findIndex((o) => o.value === this.currentValue);
+    if (idx < 0) {
+      this.thumbStyle = "display:none";
+      return;
+    }
+    const el = this.itemEls[idx];
+    if (!el) return;
+    if (this.orientation === "vertical") {
+      this.thumbStyle = `top:${el.offsetTop}px;height:${el.offsetHeight}px;left:2px;width:calc(100% - 4px)`;
+    } else {
+      this.thumbStyle = `left:${el.offsetLeft}px;width:${el.offsetWidth}px`;
+    }
+  }
+  firstUpdated() {
+    if (!this.isControlled) {
+      if (this.defaultValue !== void 0) {
+        this._internalValue = this.defaultValue;
+      } else if (this.normalizedOptions.length) {
+        const first = this.normalizedOptions.find((o) => !o.disabled);
+        if (first) this._internalValue = first.value;
+      }
+    }
+    this.updateComplete.then(() => this.updateThumb());
+  }
+  updated(changed) {
+    if (changed.has("value") || changed.has("_internalValue") || changed.has("options") || changed.has("orientation")) {
+      if (changed.has("options") && !this.isControlled) {
+        const opts = this.normalizedOptions;
+        const currentValid = opts.some((o) => o.value === this._internalValue);
+        if (!currentValid && opts.length) {
+          const first = opts.find((o) => !o.disabled);
+          if (first) this._internalValue = first.value;
+        }
+      }
+      this.updateComplete.then(() => this.updateThumb());
+    }
+  }
+  render() {
+    const opts = this.normalizedOptions;
+    const selectedValue = this.currentValue;
+    return html`
+      <div
+        class="segmented segmented-${this.orientation} segmented-${this.size} ${this.shape === "round" ? "segmented-round" : ""} ${this.block ? "segmented-block" : ""}"
+      >
+        <div class="segmented-thumb" style="${this.thumbStyle}"></div>
+        ${opts.map((opt) => {
+      const selected = opt.value === selectedValue;
+      const isDisabled = this.disabled || opt.disabled;
+      const itemContent = html`
+            <label
+              class="segmented-item ${selected ? "segmented-item-selected" : ""} ${isDisabled ? "segmented-item-disabled" : ""}"
+            >
+              <input
+                type="radio"
+                class="segmented-radio"
+                name="${this.name}"
+                .value="${String(opt.value)}"
+                .checked="${selected}"
+                ?disabled="${isDisabled}"
+                @change="${() => this.handleChange(opt)}"
+              />
+              ${opt.icon ? html`<sl-icon name="${opt.icon}" class="segmented-item-icon"></sl-icon>` : nothing}
+              ${opt.label ? typeof opt.label === "string" ? html`<span>${opt.label}</span>` : opt.label : nothing}
+              <slot name="${String(opt.value)}"></slot>
+            </label>
+          `;
+      return opt.tooltip ? html`<sl-tooltip content="${opt.tooltip}">${itemContent}</sl-tooltip>` : itemContent;
+    })}
+      </div>
+    `;
+  }
+};
+SlSegmented.styles = [component_styles_default, segmented_styles_default];
+SlSegmented.dependencies = { "sl-icon": SlIcon, "sl-tooltip": SlTooltip };
+__decorateClass([
+  property({ type: Array })
+], SlSegmented.prototype, "options", 2);
+__decorateClass([
+  property()
+], SlSegmented.prototype, "value", 2);
+__decorateClass([
+  property()
+], SlSegmented.prototype, "defaultValue", 2);
+__decorateClass([
+  property({ attribute: false })
+], SlSegmented.prototype, "onChange", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], SlSegmented.prototype, "disabled", 2);
+__decorateClass([
+  property({ type: String })
+], SlSegmented.prototype, "orientation", 2);
+__decorateClass([
+  property({ type: String })
+], SlSegmented.prototype, "shape", 2);
+__decorateClass([
+  property({ type: String })
+], SlSegmented.prototype, "size", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], SlSegmented.prototype, "block", 2);
+__decorateClass([
+  property({ type: String })
+], SlSegmented.prototype, "name", 2);
+__decorateClass([
+  state()
+], SlSegmented.prototype, "thumbStyle", 2);
+__decorateClass([
+  state()
+], SlSegmented.prototype, "_internalValue", 2);
+__decorateClass([
+  query(".segmented")
+], SlSegmented.prototype, "container", 2);
+__decorateClass([
+  queryAll(".segmented-item")
+], SlSegmented.prototype, "itemEls", 2);
+
+export {
+  SlSegmented
+};

package/dist/chunks/chunk.FMHLWHNI.js

@@ -0,0 +1,11 @@
+import {
+  SlDropdown
+} from "./chunk.RNGCZFF2.js";
+
+// src/components/dropdown/dropdown.ts
+var dropdown_default = SlDropdown;
+SlDropdown.define("sl-dropdown");
+
+export {
+  dropdown_default
+};

package/dist/chunks/chunk.FMROHC6E.js

@@ -0,0 +1,21 @@
+import {
+  SlSteps
+} from "./chunk.E5HWNRCQ.js";
+
+// src/react/steps/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "sl-steps";
+SlSteps.define("sl-steps");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlSteps,
+  react: React,
+  events: {},
+  displayName: "SlSteps"
+});
+var steps_default = reactWrapper;
+
+export {
+  steps_default
+};

package/dist/chunks/chunk.FPDBTSPA.js

@@ -0,0 +1,11 @@
+import {
+  SlPopup
+} from "./chunk.FTNJT2E2.js";
+
+// src/components/popup/popup.ts
+var popup_default = SlPopup;
+SlPopup.define("sl-popup");
+
+export {
+  popup_default
+};