@kdcloudjs/shoelace 1.0.13 → 1.0.14

package/dist/chunks/chunk.2DWQVEIZ.js

@@ -0,0 +1,24 @@
+import {
+  SlPopup
+} from "./chunk.Y5O5JHJ4.js";
+
+// src/react/popup/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "sl-popup";
+SlPopup.define("sl-popup");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: SlPopup,
+  react: React,
+  events: {
+    onSlReposition: "sl-reposition"
+  },
+  displayName: "SlPopup"
+});
+var popup_default = reactWrapper;
+
+export {
+  popup_default
+};

package/dist/chunks/chunk.2FSVIWBT.js

@@ -0,0 +1,11 @@
+import {
+  SlRange
+} from "./chunk.WLI4RPET.js";
+
+// src/components/range/range.ts
+var range_default = SlRange;
+SlRange.define("sl-range");
+
+export {
+  range_default
+};

package/dist/chunks/chunk.2MJ37SAI.js

@@ -0,0 +1,52 @@
+import {
+  ShoelaceElement
+} from "./chunk.AFYNEPK3.js";
+import {
+  __decorateClass
+} from "./chunk.W5KB6T3Z.js";
+
+// src/components/table/spinner-container.ts
+import { html } from "lit";
+import { property } from "lit/decorators.js";
+var SpinnerContainer = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.loading = false;
+  }
+  render() {
+    return html`<div class="spinner-container">
+        ${this.loading ? html`<div class="spinner-overlay"></div>
+              <sl-spinner class="spinner" style="font-size: 2rem;"></sl-spinner>` : ""}
+        <slot></slot>
+      </div>
+      <style>
+        .spinner-container {
+          position: relative;
+        }
+        .spinner-overlay {
+          position: absolute;
+          top: 0;
+          left: 0;
+          width: 100%;
+          height: 100%;
+          z-index: var(--sl-z-index-table-overlay);
+          background-color: var(--sl-table-mask);
+        }
+        .spinner {
+          z-index: calc(var(--sl-z-index-table-overlay) + 1);
+          position: absolute;
+          top: 50%;
+          left: 50%;
+          transform: translate(-50%, -50%);
+        }
+      </style> `;
+  }
+};
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], SpinnerContainer.prototype, "loading", 2);
+SpinnerContainer.define("sl-table-spinner-container");
+
+export {
+  SpinnerContainer
+};

package/dist/chunks/chunk.2QDWTIV5.js

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

package/dist/chunks/chunk.2SCRUQKD.js

@@ -0,0 +1,11 @@
+import {
+  SlCard
+} from "./chunk.URUACMGN.js";
+
+// src/components/card/card.ts
+var card_default = SlCard;
+SlCard.define("sl-card");
+
+export {
+  card_default
+};

package/dist/chunks/chunk.2U33PC3U.js

@@ -0,0 +1,27 @@
+import {
+  SlDatePanel
+} from "./chunk.QIJTEMBD.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.2WNR5NMQ.js

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

package/dist/chunks/chunk.2ZMECS6C.js

@@ -0,0 +1,338 @@
+import {
+  PickerBase
+} from "./chunk.KY3BSQFK.js";
+import {
+  SlDatePanel
+} from "./chunk.QIJTEMBD.js";
+import {
+  SlCalendar,
+  formatDatetime,
+  parseDatetime
+} from "./chunk.KQ4EXMG7.js";
+import {
+  SlDrawer
+} from "./chunk.H62BJSTW.js";
+import {
+  SlInput
+} from "./chunk.VOXLBXHE.js";
+import {
+  SlPopup
+} from "./chunk.Y5O5JHJ4.js";
+import {
+  SlButton
+} from "./chunk.JVMOPEJO.js";
+import {
+  watch
+} from "./chunk.55S3OOTM.js";
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+import {
+  __decorateClass
+} from "./chunk.W5KB6T3Z.js";
+
+// src/components/datepicker/datepicker.component.ts
+import { html } from "lit";
+import { property, query, state } from "lit/decorators.js";
+
+// src/components/datepicker/datepicker.style.ts
+import { css } from "lit";
+var datepicker_style_default = css`
+  :host {
+    display: inline-block;
+  }
+
+  .datepicker__popup::part(popup) {
+    z-index: var(--sl-z-index-dropdown);
+  }
+
+  .datepicker__calendar {
+    display: block;
+  }
+`;
+
+// src/components/datepicker/datepicker.component.ts
+var SlDatepicker = class extends PickerBase {
+  constructor() {
+    super(...arguments);
+    this.type = "date";
+    this.min = "0001-01-01";
+    this.max = "9999-12-31";
+  }
+  handleOpenChange() {
+    if (this.open) {
+      if (this.calendar) {
+        this.calendar.resetView();
+      }
+    }
+    if (!this.open) {
+      this.handleValueChange();
+    }
+  }
+  parseValue(value) {
+    return parseDatetime(value);
+  }
+  formatValue(date) {
+    return formatDatetime(date, this.type);
+  }
+  isValidFormat(value) {
+    if (this.type === "date") {
+      return /^\d{4}[-./]\d{2}[-./]\d{2}$/.test(value);
+    }
+    if (this.type === "datetime") {
+      return /^\d{4}[-./]\d{2}[-./]\d{2}\s+\d{2}:\d{2}:\d{2}$/.test(value);
+    }
+    return true;
+  }
+  isValidValue(date) {
+    let isValid = !!date;
+    if (date) {
+      const minDate = this.parseValue(String(this.min));
+      const maxDate = this.parseValue(String(this.max));
+      if (minDate && date < minDate) {
+        isValid = false;
+      }
+      if (maxDate && date > maxDate) {
+        isValid = false;
+      }
+    }
+    return isValid;
+  }
+  getInputPattern() {
+    return this.pattern;
+  }
+  getInputSuffixIconName() {
+    return "calendar4";
+  }
+  shouldRevertOnBlur() {
+    return this.type === "datetime";
+  }
+  async handleInputInput(event) {
+    event.stopPropagation();
+    const target = event.target;
+    const value = target.value;
+    const isValidFormat = this.isValidFormat(value);
+    if (isValidFormat && this.parseValue(value) || !this.open && value === "") {
+      this.updateValue(value, { emitInput: true });
+    }
+    await this.updateComplete;
+    if (!this.open && value !== "") {
+      this.open = true;
+    }
+  }
+  handleDateSelect(event) {
+    const selectedDate = event.detail.date;
+    const formattedDate = formatDatetime(selectedDate, this.type);
+    this.updateValue(formattedDate, { emitInput: true, emitChange: true });
+    if (this.input) {
+      this.input.focus();
+    }
+    if (!this.isMobile) {
+      this.open = false;
+    }
+  }
+  handleDateChange(event) {
+    const selectedDate = event.detail.date;
+    const formattedDate = formatDatetime(selectedDate, this.type);
+    this.updateValue(formattedDate, { emitInput: true, emitChange: false });
+  }
+  blur() {
+    if (this.isMobile && this.open) {
+      return;
+    }
+    super.blur();
+  }
+  handleInputKeyDown(event) {
+    super.handleInputKeyDown(event);
+    if (event.key === "Enter") {
+      const parsedDate = this.parseValue(this.value);
+      const isValid = this.isValidValue(parsedDate);
+      if (!isValid) {
+        return;
+      }
+      if (this.open && this.calendar) {
+        event.stopPropagation();
+        this.calendar.handleKeyDown(event);
+        return;
+      }
+      if (parsedDate) {
+        const formattedDate = this.formatValue(parsedDate);
+        this.updateValue(formattedDate, { emitChange: true });
+        this.open = false;
+      }
+    }
+  }
+  handleValueChange() {
+    const validDate = this.parseValue(this.value);
+    const isValid = this.isValidValue(validDate);
+    if (!this.open || this.type === "date" && !this.isMobile) {
+      if (validDate && isValid) {
+        const formattedDate = this.formatValue(validDate);
+        this.lastValidValue = formattedDate;
+      } else if (this.value === "") {
+        this.lastValidValue = "";
+      }
+    }
+    if (!this.value || !this.calendar || !isValid || !this.input) {
+      return;
+    }
+    this.formControlController.updateValidity();
+    if (this.valueChangeDebounceTimer) {
+      window.clearTimeout(this.valueChangeDebounceTimer);
+    }
+    this.valueChangeDebounceTimer = window.setTimeout(() => {
+      const parsedDate = this.parseValue(this.value);
+      if (parsedDate) {
+        this.calendar.value = this.value;
+      }
+      this.valueChangeDebounceTimer = void 0;
+    }, 300);
+  }
+  renderCalendar() {
+    return html`
+      <sl-calendar
+        part="calendar"
+        exportparts="
+          base:calendar-base,
+          header:calendar-header,
+          nav-button:calendar-nav-button,
+          title:calendar-title,
+          title-year:calendar-title-year,
+          title-month:calendar-title-month,
+          body:calendar-body,
+          date-panel:calendar-date-panel,
+          day-header:calendar-day-header,
+          day:calendar-day,
+          day-footer:calendar-day-footer,
+          month-grid:calendar-month-grid,
+          month-item:calendar-month-item,
+          year-grid:calendar-year-grid,
+          year-item:calendar-year-item,
+          time-footer:calendar-time-footer,
+          time-panel-base,
+          time-panel-header,
+          time-panel-margin-cell-first,
+          time-panel-margin-cell,
+          time-panel-columns,
+          time-panel-column,
+          time-panel-hour,
+          time-panel-minute,
+          time-panel-second,
+          time-panel-item,
+          time-panel-footer
+        "
+        class="datepicker__calendar"
+        .value=${this.parseValue(this.value) ? this.value : this.lastValidValue}
+        type=${this.type}
+        min=${this.min}
+        max=${this.max}
+        @sl-date-select=${this.handleDateSelect}
+        @sl-date-change=${this.handleDateChange}
+        @click=${(event) => event.stopPropagation()}
+      ></sl-calendar>
+    `;
+  }
+  renderPopup() {
+    return html`
+      <sl-popup
+        part="popup"
+        class="datepicker__popup"
+        ?active=${this.open}
+        strategy=${this.hoist ? "fixed" : "absolute"}
+        flip
+        shift
+        placement="bottom-start"
+        auto-size="vertical"
+        auto-size-padding="10"
+      >
+        ${this.renderInput("anchor")} ${this.renderCalendar()}
+      </sl-popup>
+    `;
+  }
+  render() {
+    if (this.isMobile) {
+      return html`
+        ${this.renderInput()}
+        <sl-date-panel
+          exportparts="
+            calendar-base,
+            calendar-header,
+            calendar-nav-button,
+            calendar-title,
+            calendar-title-year,
+            calendar-title-month,
+            calendar-body,
+            calendar-date-panel,
+            calendar-day-header,
+            calendar-day,
+            calendar-day-footer,
+            calendar-month-grid,
+            calendar-month-item,
+            calendar-year-grid,
+            calendar-year-item,
+            calendar-time-footer,
+            time-panel-base,
+            time-panel-header,
+            time-panel-margin-cell-first,
+            time-panel-margin-cell,
+            time-panel-columns,
+            time-panel-column,
+            time-panel-hour,
+            time-panel-minute,
+            time-panel-second,
+            time-panel-item,
+            time-panel-footer
+          "
+          .value=${this.value}
+          .open=${this.open}
+          .min=${this.min}
+          .max=${this.max}
+          .type=${this.type}
+          @sl-date-select=${this.handleDateSelect}
+          @sl-date-change=${this.handleDateChange}
+          @sl-confirm=${this.handleMobileConfirm}
+          @sl-cancel=${this.handleMobileCancel}
+          @sl-clear=${this.handleMobileClear}
+        ></sl-date-panel>
+      `;
+    }
+    return this.renderPopup();
+  }
+};
+SlDatepicker.styles = [component_styles_default, datepicker_style_default];
+SlDatepicker.dependencies = {
+  "sl-button": SlButton,
+  "sl-calendar": SlCalendar,
+  "sl-date-panel": SlDatePanel,
+  "sl-drawer": SlDrawer,
+  "sl-popup": SlPopup,
+  "sl-input": SlInput
+};
+__decorateClass([
+  query("sl-calendar")
+], SlDatepicker.prototype, "calendar", 2);
+__decorateClass([
+  state()
+], SlDatepicker.prototype, "valueChangeDebounceTimer", 2);
+__decorateClass([
+  property({ reflect: true })
+], SlDatepicker.prototype, "type", 2);
+__decorateClass([
+  property()
+], SlDatepicker.prototype, "pattern", 2);
+__decorateClass([
+  property()
+], SlDatepicker.prototype, "min", 2);
+__decorateClass([
+  property()
+], SlDatepicker.prototype, "max", 2);
+__decorateClass([
+  watch("open", { waitUntilFirstUpdate: true })
+], SlDatepicker.prototype, "handleOpenChange", 1);
+__decorateClass([
+  watch("value")
+], SlDatepicker.prototype, "handleValueChange", 1);
+
+export {
+  SlDatepicker
+};

package/dist/chunks/chunk.33U6HVX6.js

@@ -0,0 +1,11 @@
+import {
+  SlCheckbox
+} from "./chunk.5PEZ5XRN.js";
+
+// src/components/checkbox/checkbox.ts
+var checkbox_default = SlCheckbox;
+SlCheckbox.define("sl-checkbox");
+
+export {
+  checkbox_default
+};

package/dist/chunks/chunk.3653MYZD.js

@@ -0,0 +1,90 @@
+import {
+  breadcrumb_styles_default
+} from "./chunk.P4NYDBZP.js";
+import {
+  LocalizeController
+} from "./chunk.6CTB5ZDJ.js";
+import {
+  SlIcon
+} from "./chunk.XRMWGB46.js";
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+import {
+  ShoelaceElement
+} from "./chunk.AFYNEPK3.js";
+import {
+  __decorateClass
+} from "./chunk.W5KB6T3Z.js";
+
+// src/components/breadcrumb/breadcrumb.component.ts
+import { html } from "lit";
+import { property, query } from "lit/decorators.js";
+var SlBreadcrumb = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.localize = new LocalizeController(this);
+    this.separatorDir = this.localize.dir();
+    this.label = "";
+  }
+  // Generates a clone of the separator element to use for each breadcrumb item
+  getSeparator() {
+    const separator = this.separatorSlot.assignedElements({ flatten: true })[0];
+    const clone = separator.cloneNode(true);
+    [clone, ...clone.querySelectorAll("[id]")].forEach((el) => el.removeAttribute("id"));
+    clone.setAttribute("data-default", "");
+    clone.slot = "separator";
+    return clone;
+  }
+  handleSlotChange() {
+    const items = [...this.defaultSlot.assignedElements({ flatten: true })].filter(
+      (item) => item.tagName.toLowerCase() === "sl-breadcrumb-item"
+    );
+    items.forEach((item, index) => {
+      const separator = item.querySelector('[slot="separator"]');
+      if (separator === null) {
+        item.append(this.getSeparator());
+      } else if (separator.hasAttribute("data-default")) {
+        separator.replaceWith(this.getSeparator());
+      } else {
+      }
+      if (index === items.length - 1) {
+        item.setAttribute("aria-current", "page");
+      } else {
+        item.removeAttribute("aria-current");
+      }
+    });
+  }
+  render() {
+    if (this.separatorDir !== this.localize.dir()) {
+      this.separatorDir = this.localize.dir();
+      this.updateComplete.then(() => this.handleSlotChange());
+    }
+    return html`
+      <nav part="base" class="breadcrumb" aria-label=${this.label}>
+        <slot @slotchange=${this.handleSlotChange}></slot>
+      </nav>
+
+      <span hidden aria-hidden="true">
+        <slot name="separator">
+          <sl-icon name=${this.localize.dir() === "rtl" ? "chevron-left" : "chevron-right"} library="system"></sl-icon>
+        </slot>
+      </span>
+    `;
+  }
+};
+SlBreadcrumb.styles = [component_styles_default, breadcrumb_styles_default];
+SlBreadcrumb.dependencies = { "sl-icon": SlIcon };
+__decorateClass([
+  query("slot")
+], SlBreadcrumb.prototype, "defaultSlot", 2);
+__decorateClass([
+  query('slot[name="separator"]')
+], SlBreadcrumb.prototype, "separatorSlot", 2);
+__decorateClass([
+  property()
+], SlBreadcrumb.prototype, "label", 2);
+
+export {
+  SlBreadcrumb
+};

package/dist/chunks/chunk.3FXHNSLI.js

@@ -0,0 +1,11 @@
+import {
+  SlMutationObserver
+} from "./chunk.KVVR3R4U.js";
+
+// src/components/mutation-observer/mutation-observer.ts
+var mutation_observer_default = SlMutationObserver;
+SlMutationObserver.define("sl-mutation-observer");
+
+export {
+  mutation_observer_default
+};

package/dist/chunks/chunk.3HZENZXD.js

@@ -0,0 +1,11 @@
+import {
+  SlRating
+} from "./chunk.AVAYUR5U.js";
+
+// src/components/rating/rating.ts
+var rating_default = SlRating;
+SlRating.define("sl-rating");
+
+export {
+  rating_default
+};

package/dist/chunks/chunk.3I2KTUUN.js

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

package/dist/chunks/chunk.3IIEFVL6.js

@@ -0,0 +1,11 @@
+import {
+  SlRadio
+} from "./chunk.X25CNFY5.js";
+
+// src/components/radio/radio.ts
+var radio_default = SlRadio;
+SlRadio.define("sl-radio");
+
+export {
+  radio_default
+};

package/dist/chunks/chunk.45B6NU5V.js

@@ -0,0 +1,22 @@
+import {
+  visually_hidden_styles_default
+} from "./chunk.YKKSQ2FG.js";
+import {
+  component_styles_default
+} from "./chunk.TUVJKY7S.js";
+import {
+  ShoelaceElement
+} from "./chunk.AFYNEPK3.js";
+
+// src/components/visually-hidden/visually-hidden.component.ts
+import { html } from "lit";
+var SlVisuallyHidden = class extends ShoelaceElement {
+  render() {
+    return html` <slot></slot> `;
+  }
+};
+SlVisuallyHidden.styles = [component_styles_default, visually_hidden_styles_default];
+
+export {
+  SlVisuallyHidden
+};