@kdcloudjs/shoelace 1.0.25 → 1.0.26

package/cdn/chunks/chunk.RMAW3G3Z.js

@@ -0,0 +1,331 @@
+import {
+  thought_chain_node_styles_default
+} from "./chunk.X7TJS7PC.js";
+import {
+  SlSpinner
+} from "./chunk.Q7NF2C45.js";
+import {
+  e
+} from "./chunk.VHCLMDG7.js";
+import {
+  SlIcon
+} from "./chunk.W7DAHZRF.js";
+import {
+  component_styles_default
+} from "./chunk.NDXSHFSW.js";
+import {
+  ShoelaceElement,
+  e as e2,
+  n,
+  r
+} from "./chunk.KT6MOS3J.js";
+import {
+  A,
+  b
+} from "./chunk.7WSF3BCU.js";
+import {
+  __decorateClass
+} from "./chunk.CZCSAYQZ.js";
+
+// src/components/thought-chain-node/thought-chain-node.component.ts
+var STATUS_ICON_NAMES = {
+  success: "check-circle",
+  error: "x-circle",
+  abort: "dash-circle"
+};
+var SlThoughtChainNode = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.nodeKey = "";
+    this.title = "";
+    this.description = "";
+    this.status = "";
+    this.collapsible = false;
+    this.blink = false;
+    this.noIcon = false;
+    this._lineStyle = "solid";
+    this._size = "middle";
+    this._isLast = false;
+    this._index = 0;
+    this._expandedKeys = [];
+    this._hasDefaultSlotContent = false;
+    this._hasFooterSlotContent = false;
+    this._hasDescriptionSlotContent = false;
+    this._hasIconSlotContent = false;
+    this._hasTitleSlotContent = false;
+    /** Track previous expanded state for animation */
+    this._prevExpanded = null;
+  }
+  /** Whether this node's content is currently expanded */
+  get expanded() {
+    if (!this.collapsible) return true;
+    return this._expandedKeys.includes(this.nodeKey);
+  }
+  firstUpdated() {
+    if (this.collapsible && !this.expanded && this.contentEl) {
+      this.contentEl.style.height = "0";
+      this.contentEl.style.overflow = "hidden";
+    }
+    this._detectSlotContent();
+  }
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    if (this._isLast) {
+      this.setAttribute("data-last", "");
+    } else {
+      this.removeAttribute("data-last");
+    }
+    if (changedProperties.has("_expandedKeys") && this.collapsible && this.contentEl) {
+      const currentExpanded = this.expanded;
+      if (this._prevExpanded !== null && this._prevExpanded !== currentExpanded) {
+        this.animateContent(currentExpanded);
+      }
+      this._prevExpanded = currentExpanded;
+    }
+  }
+  async animateContent(expanding) {
+    const el = this.contentEl;
+    if (!el) return;
+    if (expanding) {
+      el.style.height = "auto";
+      el.style.overflow = "hidden";
+      const fullHeight = el.scrollHeight;
+      el.style.height = "0";
+      void el.offsetHeight;
+      const anim = el.animate(
+        [
+          { height: "0", opacity: "0" },
+          { height: `${fullHeight}px`, opacity: "1" }
+        ],
+        { duration: 250, easing: "ease", fill: "forwards" }
+      );
+      await anim.finished;
+      anim.cancel();
+      el.style.height = "auto";
+      el.style.overflow = "";
+    } else {
+      const currentHeight = el.scrollHeight;
+      el.style.overflow = "hidden";
+      const anim = el.animate(
+        [
+          { height: `${currentHeight}px`, opacity: "1" },
+          { height: "0", opacity: "0" }
+        ],
+        { duration: 250, easing: "ease", fill: "forwards" }
+      );
+      await anim.finished;
+      anim.cancel();
+      el.style.height = "0";
+      el.style.overflow = "hidden";
+    }
+  }
+  handleTitleClick() {
+    if (this.collapsible && this._onExpand) {
+      this._onExpand(this.nodeKey);
+    }
+  }
+  handleTitleKeyDown(event) {
+    if (event.key === "Enter" || event.key === " ") {
+      event.preventDefault();
+      this.handleTitleClick();
+    }
+  }
+  /** Detect slot content on slotchange events */
+  _detectSlotContent() {
+    this._hasDefaultSlotContent = this._checkSlotHasContent("");
+    this._hasFooterSlotContent = this._checkSlotHasContent("footer");
+    this._hasDescriptionSlotContent = this._checkSlotHasContent("description");
+    this._hasIconSlotContent = this._checkSlotHasContent("icon");
+    this._hasTitleSlotContent = this._checkSlotHasContent("title");
+  }
+  /** Check if a slot has assigned non-empty nodes */
+  _checkSlotHasContent(slotName) {
+    if (slotName === "") {
+      const children = Array.from(this.childNodes);
+      return children.some((node) => {
+        var _a;
+        if (node instanceof Element && !node.hasAttribute("slot")) return true;
+        if (node.nodeType === Node.TEXT_NODE && ((_a = node.textContent) == null ? void 0 : _a.trim())) return true;
+        return false;
+      });
+    }
+    return this.querySelector(`[slot="${slotName}"]`) !== null;
+  }
+  /** Handle all slot changes */
+  handleSlotChange() {
+    this._detectSlotContent();
+  }
+  /** Render the icon area */
+  renderIcon() {
+    if (this.noIcon) return A;
+    const lineStyle = this._lineStyle;
+    let iconContent;
+    if (this.status === "loading") {
+      iconContent = b`
+        <span class="thought-chain-node__status-icon thought-chain-node__status-icon--loading">
+          <sl-spinner></sl-spinner>
+        </span>
+      `;
+    } else if (this.status && STATUS_ICON_NAMES[this.status]) {
+      iconContent = b`
+        <span class="thought-chain-node__status-icon">
+          <sl-icon name=${STATUS_ICON_NAMES[this.status]}></sl-icon>
+        </span>
+      `;
+    } else if (this._hasIconSlotContent) {
+      iconContent = b`<slot name="icon" @slotchange=${this.handleSlotChange}></slot>`;
+    } else {
+      iconContent = b`<span class="thought-chain-node__index-icon">${this._index + 1}</span>`;
+    }
+    return b`
+      <div
+        part="icon"
+        class=${e({
+      "thought-chain-node__icon": true,
+      [`thought-chain-node__icon--${this.status}`]: !!this.status,
+      "thought-chain-node__icon--dashed": lineStyle === "dashed",
+      "thought-chain-node__icon--dotted": lineStyle === "dotted",
+      "thought-chain-node__icon--no-line": lineStyle === "none"
+    })}
+      >
+        ${iconContent}
+      </div>
+    `;
+  }
+  render() {
+    const hasDescription = this.description || this._hasDescriptionSlotContent;
+    const isExpanded = this.expanded;
+    if (this._prevExpanded === null) {
+      this._prevExpanded = isExpanded;
+    }
+    return b`
+      <div
+        part="base"
+        class=${e({
+      "thought-chain-node": true,
+      [`thought-chain-node--${this._size}`]: true
+    })}
+      >
+        ${this.renderIcon()}
+        <div class="thought-chain-node__body">
+          <!-- Header -->
+          <div part="header" class="thought-chain-node__header">
+            <div
+              part="title"
+              class=${e({
+      "thought-chain-node__title": true,
+      "thought-chain-node__title--collapsible": this.collapsible,
+      "thought-chain-node__blink": this.blink
+    })}
+              @click=${this.collapsible ? this.handleTitleClick : null}
+              @keydown=${this.collapsible ? this.handleTitleKeyDown : null}
+              tabindex=${this.collapsible ? "0" : A}
+              role=${this.collapsible ? "button" : A}
+              aria-expanded=${this.collapsible ? isExpanded ? "true" : "false" : A}
+            >
+              <slot name="title" @slotchange=${this.handleSlotChange}>${this.title}</slot>
+              ${this.collapsible && this._hasDefaultSlotContent ? b`
+                    <span
+                      part="collapse-icon"
+                      class=${e({
+      "thought-chain-node__collapse-icon": true,
+      "thought-chain-node__collapse-icon--expanded": isExpanded
+    })}
+                      aria-hidden="true"
+                    >
+                      <sl-icon name="chevron-down"></sl-icon>
+                    </span>
+                  ` : A}
+            </div>
+            ${hasDescription ? b`
+                  <div part="description" class="thought-chain-node__description">
+                    <slot name="description" @slotchange=${this.handleSlotChange}>${this.description}</slot>
+                  </div>
+                ` : A}
+          </div>
+          <!-- Content area: hidden when collapsed or when no content exists for non-collapsible nodes -->
+          <div
+            part="content"
+            class="thought-chain-node__content"
+            style=${!this.collapsible && !this._hasDefaultSlotContent ? "display:none" : ""}
+          >
+            <div part="content-inner" class="thought-chain-node__content-inner">
+              <slot @slotchange=${this.handleSlotChange}></slot>
+            </div>
+          </div>
+          <!-- Footer -->
+          <div
+            part="footer"
+            class="thought-chain-node__footer"
+            style=${this._hasFooterSlotContent ? "" : "display:none"}
+          >
+            <slot name="footer" @slotchange=${this.handleSlotChange}></slot>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+};
+SlThoughtChainNode.styles = [component_styles_default, thought_chain_node_styles_default];
+SlThoughtChainNode.dependencies = {
+  "sl-icon": SlIcon,
+  "sl-spinner": SlSpinner
+};
+__decorateClass([
+  e2(".thought-chain-node__content")
+], SlThoughtChainNode.prototype, "contentEl", 2);
+__decorateClass([
+  n({ attribute: "node-key", reflect: true })
+], SlThoughtChainNode.prototype, "nodeKey", 2);
+__decorateClass([
+  n()
+], SlThoughtChainNode.prototype, "title", 2);
+__decorateClass([
+  n()
+], SlThoughtChainNode.prototype, "description", 2);
+__decorateClass([
+  n({ reflect: true })
+], SlThoughtChainNode.prototype, "status", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlThoughtChainNode.prototype, "collapsible", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlThoughtChainNode.prototype, "blink", 2);
+__decorateClass([
+  n({ attribute: "no-icon", type: Boolean, reflect: true })
+], SlThoughtChainNode.prototype, "noIcon", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_lineStyle", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_size", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_isLast", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_index", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_expandedKeys", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_hasDefaultSlotContent", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_hasFooterSlotContent", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_hasDescriptionSlotContent", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_hasIconSlotContent", 2);
+__decorateClass([
+  r()
+], SlThoughtChainNode.prototype, "_hasTitleSlotContent", 2);
+
+export {
+  SlThoughtChainNode
+};

package/cdn/chunks/chunk.RR4UA2LZ.js

@@ -0,0 +1,42 @@
+import {
+  divider_styles_default
+} from "./chunk.GJIRETQU.js";
+import {
+  watch
+} from "./chunk.WID3TCT6.js";
+import {
+  component_styles_default
+} from "./chunk.NDXSHFSW.js";
+import {
+  ShoelaceElement,
+  n
+} from "./chunk.KT6MOS3J.js";
+import {
+  __decorateClass
+} from "./chunk.CZCSAYQZ.js";
+
+// src/components/divider/divider.component.ts
+var SlDivider = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.vertical = false;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.setAttribute("role", "separator");
+  }
+  handleVerticalChange() {
+    this.setAttribute("aria-orientation", this.vertical ? "vertical" : "horizontal");
+  }
+};
+SlDivider.styles = [component_styles_default, divider_styles_default];
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlDivider.prototype, "vertical", 2);
+__decorateClass([
+  watch("vertical")
+], SlDivider.prototype, "handleVerticalChange", 1);
+
+export {
+  SlDivider
+};

package/cdn/chunks/chunk.S4YX6XNZ.js

@@ -0,0 +1,27 @@
+import {
+  carousel_item_styles_default
+} from "./chunk.FFVGCBGA.js";
+import {
+  component_styles_default
+} from "./chunk.NDXSHFSW.js";
+import {
+  ShoelaceElement
+} from "./chunk.KT6MOS3J.js";
+import {
+  b
+} from "./chunk.7WSF3BCU.js";
+
+// src/components/carousel-item/carousel-item.component.ts
+var SlCarouselItem = class extends ShoelaceElement {
+  connectedCallback() {
+    super.connectedCallback();
+  }
+  render() {
+    return b` <slot></slot> `;
+  }
+};
+SlCarouselItem.styles = [component_styles_default, carousel_item_styles_default];
+
+export {
+  SlCarouselItem
+};

package/cdn/chunks/chunk.S5EXKHN3.js

@@ -0,0 +1,299 @@
+import {
+  split_panel_styles_default
+} from "./chunk.UNBPKX7A.js";
+import {
+  drag
+} from "./chunk.ESELY2US.js";
+import {
+  clamp
+} from "./chunk.HF7GESMZ.js";
+import {
+  LocalizeController
+} from "./chunk.2SU6QBUU.js";
+import {
+  o
+} from "./chunk.KJQP3AWV.js";
+import {
+  watch
+} from "./chunk.WID3TCT6.js";
+import {
+  component_styles_default
+} from "./chunk.NDXSHFSW.js";
+import {
+  ShoelaceElement,
+  e,
+  n
+} from "./chunk.KT6MOS3J.js";
+import {
+  b
+} from "./chunk.7WSF3BCU.js";
+import {
+  __decorateClass
+} from "./chunk.CZCSAYQZ.js";
+
+// src/components/split-panel/split-panel.component.ts
+var SNAP_NONE = () => null;
+var SlSplitPanel = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.isCollapsed = false;
+    this.localize = new LocalizeController(this);
+    this.positionBeforeCollapsing = 0;
+    this.position = 50;
+    this.vertical = false;
+    this.disabled = false;
+    // Returned when the property is queried, so that string 'snap's are preserved.
+    this.snapValue = "";
+    // Actually used for computing snap points. All string snaps are converted via `toSnapFunction`.
+    this.snapFunction = SNAP_NONE;
+    this.snapThreshold = 12;
+  }
+  /**
+   * Converts a string containing either a series of fixed/repeated snap points (e.g. "repeat(20%)", "100px 200px 800px", or "10% 50% repeat(10px)") into a SnapFunction. `SnapFunction`s take in a `SnapFunctionOpts` and return the position that the split panel should snap to.
+   *
+   * @param snap - The snap string.
+   * @returns a `SnapFunction` representing the snap string's logic.
+   */
+  toSnapFunction(snap) {
+    const snapPoints = snap.split(" ");
+    return ({ pos, size, snapThreshold, isRtl, vertical }) => {
+      let newPos = pos;
+      let minDistance = Number.POSITIVE_INFINITY;
+      snapPoints.forEach((value) => {
+        let snapPoint;
+        if (value.startsWith("repeat(")) {
+          const repeatVal = snap.substring("repeat(".length, snap.length - 1);
+          const isPercent = repeatVal.endsWith("%");
+          const repeatNum = Number.parseFloat(repeatVal);
+          const snapIntervalPx = isPercent ? size * (repeatNum / 100) : repeatNum;
+          snapPoint = Math.round((isRtl && !vertical ? size - pos : pos) / snapIntervalPx) * snapIntervalPx;
+        } else if (value.endsWith("%")) {
+          snapPoint = size * (Number.parseFloat(value) / 100);
+        } else {
+          snapPoint = Number.parseFloat(value);
+        }
+        if (isRtl && !vertical) {
+          snapPoint = size - snapPoint;
+        }
+        const distance = Math.abs(pos - snapPoint);
+        if (distance <= snapThreshold && distance < minDistance) {
+          newPos = snapPoint;
+          minDistance = distance;
+        }
+      });
+      return newPos;
+    };
+  }
+  set snap(snap) {
+    this.snapValue = snap != null ? snap : "";
+    if (snap) {
+      this.snapFunction = typeof snap === "string" ? this.toSnapFunction(snap) : snap;
+    } else {
+      this.snapFunction = SNAP_NONE;
+    }
+  }
+  get snap() {
+    return this.snapValue;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.resizeObserver = new ResizeObserver((entries) => this.handleResize(entries));
+    this.updateComplete.then(() => this.resizeObserver.observe(this));
+    this.detectSize();
+    this.cachedPositionInPixels = this.percentageToPixels(this.position);
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = this.resizeObserver) == null ? void 0 : _a.unobserve(this);
+  }
+  detectSize() {
+    const { width, height } = this.getBoundingClientRect();
+    this.size = this.vertical ? height : width;
+  }
+  percentageToPixels(value) {
+    return this.size * (value / 100);
+  }
+  pixelsToPercentage(value) {
+    return value / this.size * 100;
+  }
+  handleDrag(event) {
+    const isRtl = this.localize.dir() === "rtl";
+    if (this.disabled) {
+      return;
+    }
+    if (event.cancelable) {
+      event.preventDefault();
+    }
+    drag(this, {
+      onMove: (x, y) => {
+        var _a;
+        let newPositionInPixels = this.vertical ? y : x;
+        if (this.primary === "end") {
+          newPositionInPixels = this.size - newPositionInPixels;
+        }
+        newPositionInPixels = (_a = this.snapFunction({
+          pos: newPositionInPixels,
+          size: this.size,
+          snapThreshold: this.snapThreshold,
+          isRtl,
+          vertical: this.vertical
+        })) != null ? _a : newPositionInPixels;
+        this.position = clamp(this.pixelsToPercentage(newPositionInPixels), 0, 100);
+      },
+      initialEvent: event
+    });
+  }
+  handleKeyDown(event) {
+    if (this.disabled) {
+      return;
+    }
+    if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End", "Enter"].includes(event.key)) {
+      let newPosition = this.position;
+      const incr = (event.shiftKey ? 10 : 1) * (this.primary === "end" ? -1 : 1);
+      event.preventDefault();
+      if (event.key === "ArrowLeft" && !this.vertical || event.key === "ArrowUp" && this.vertical) {
+        newPosition -= incr;
+      }
+      if (event.key === "ArrowRight" && !this.vertical || event.key === "ArrowDown" && this.vertical) {
+        newPosition += incr;
+      }
+      if (event.key === "Home") {
+        newPosition = this.primary === "end" ? 100 : 0;
+      }
+      if (event.key === "End") {
+        newPosition = this.primary === "end" ? 0 : 100;
+      }
+      if (event.key === "Enter") {
+        if (this.isCollapsed) {
+          newPosition = this.positionBeforeCollapsing;
+          this.isCollapsed = false;
+        } else {
+          const positionBeforeCollapsing = this.position;
+          newPosition = 0;
+          requestAnimationFrame(() => {
+            this.isCollapsed = true;
+            this.positionBeforeCollapsing = positionBeforeCollapsing;
+          });
+        }
+      }
+      this.position = clamp(newPosition, 0, 100);
+    }
+  }
+  handleResize(entries) {
+    const { width, height } = entries[0].contentRect;
+    this.size = this.vertical ? height : width;
+    if (isNaN(this.cachedPositionInPixels) || this.position === Infinity) {
+      this.cachedPositionInPixels = Number(this.getAttribute("position-in-pixels"));
+      this.positionInPixels = Number(this.getAttribute("position-in-pixels"));
+      this.position = this.pixelsToPercentage(this.positionInPixels);
+    }
+    if (this.primary) {
+      this.position = this.pixelsToPercentage(this.cachedPositionInPixels);
+    }
+  }
+  handlePositionChange() {
+    this.cachedPositionInPixels = this.percentageToPixels(this.position);
+    this.isCollapsed = false;
+    this.positionBeforeCollapsing = 0;
+    this.positionInPixels = this.percentageToPixels(this.position);
+    this.emit("sl-reposition");
+  }
+  handlePositionInPixelsChange() {
+    this.position = this.pixelsToPercentage(this.positionInPixels);
+  }
+  handleVerticalChange() {
+    this.detectSize();
+  }
+  render() {
+    const gridTemplate = this.vertical ? "gridTemplateRows" : "gridTemplateColumns";
+    const gridTemplateAlt = this.vertical ? "gridTemplateColumns" : "gridTemplateRows";
+    const isRtl = this.localize.dir() === "rtl";
+    const primary = `
+      clamp(
+        0%,
+        clamp(
+          var(--min),
+          ${this.position}% - var(--divider-width) / 2,
+          var(--max)
+        ),
+        calc(100% - var(--divider-width))
+      )
+    `;
+    const secondary = "auto";
+    if (this.primary === "end") {
+      if (isRtl && !this.vertical) {
+        this.style[gridTemplate] = `${primary} var(--divider-width) ${secondary}`;
+      } else {
+        this.style[gridTemplate] = `${secondary} var(--divider-width) ${primary}`;
+      }
+    } else {
+      if (isRtl && !this.vertical) {
+        this.style[gridTemplate] = `${secondary} var(--divider-width) ${primary}`;
+      } else {
+        this.style[gridTemplate] = `${primary} var(--divider-width) ${secondary}`;
+      }
+    }
+    this.style[gridTemplateAlt] = "";
+    return b`
+      <slot name="start" part="panel start" class="start"></slot>
+
+      <div
+        part="divider"
+        class="divider"
+        tabindex=${o(this.disabled ? void 0 : "0")}
+        role="separator"
+        aria-valuenow=${this.position}
+        aria-valuemin="0"
+        aria-valuemax="100"
+        aria-label=${this.localize.term("resize")}
+        @keydown=${this.handleKeyDown}
+        @mousedown=${this.handleDrag}
+        @touchstart=${this.handleDrag}
+      >
+        <slot name="divider"></slot>
+      </div>
+
+      <slot name="end" part="panel end" class="end"></slot>
+    `;
+  }
+};
+SlSplitPanel.styles = [component_styles_default, split_panel_styles_default];
+__decorateClass([
+  e(".divider")
+], SlSplitPanel.prototype, "divider", 2);
+__decorateClass([
+  n({ type: Number, reflect: true })
+], SlSplitPanel.prototype, "position", 2);
+__decorateClass([
+  n({ attribute: "position-in-pixels", type: Number })
+], SlSplitPanel.prototype, "positionInPixels", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlSplitPanel.prototype, "vertical", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], SlSplitPanel.prototype, "disabled", 2);
+__decorateClass([
+  n()
+], SlSplitPanel.prototype, "primary", 2);
+__decorateClass([
+  n({ reflect: true })
+], SlSplitPanel.prototype, "snap", 1);
+__decorateClass([
+  n({ type: Number, attribute: "snap-threshold" })
+], SlSplitPanel.prototype, "snapThreshold", 2);
+__decorateClass([
+  watch("position")
+], SlSplitPanel.prototype, "handlePositionChange", 1);
+__decorateClass([
+  watch("positionInPixels")
+], SlSplitPanel.prototype, "handlePositionInPixelsChange", 1);
+__decorateClass([
+  watch("vertical")
+], SlSplitPanel.prototype, "handleVerticalChange", 1);
+
+export {
+  SNAP_NONE,
+  SlSplitPanel
+};