@kdcloudjs/shoelace 1.0.21 → 1.0.22

package/cdn/chunks/chunk.JTC7F5FK.js

@@ -0,0 +1,246 @@
+import {
+  e,
+  n
+} from "./chunk.G2YOMCHR.js";
+import {
+  b
+} from "./chunk.7WSF3BCU.js";
+
+// src/components/menu-item/submenu-controller.ts
+var SubmenuController = class {
+  constructor(host, hasSlotController) {
+    this.popupRef = e();
+    this.enableSubmenuTimer = -1;
+    this.isConnected = false;
+    this.isPopupConnected = false;
+    this.skidding = 0;
+    this.submenuOpenDelay = 100;
+    // Set the safe triangle cursor position
+    this.handleMouseMove = (event) => {
+      this.host.style.setProperty("--safe-triangle-cursor-x", `${event.clientX}px`);
+      this.host.style.setProperty("--safe-triangle-cursor-y", `${event.clientY}px`);
+    };
+    this.handleMouseOver = () => {
+      if (this.hasSlotController.test("submenu")) {
+        this.enableSubmenu();
+      }
+    };
+    // Focus on the first menu-item of a submenu.
+    this.handleKeyDown = (event) => {
+      switch (event.key) {
+        case "Escape":
+        case "Tab":
+          this.disableSubmenu();
+          break;
+        case "ArrowLeft":
+          if (event.target !== this.host) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.host.focus();
+            this.disableSubmenu();
+          }
+          break;
+        case "ArrowRight":
+        case "Enter":
+        case " ":
+          this.handleSubmenuEntry(event);
+          break;
+        default:
+          break;
+      }
+    };
+    this.handleClick = (event) => {
+      var _a;
+      if (event.target === this.host) {
+        event.preventDefault();
+        event.stopPropagation();
+      } else if (event.target instanceof Element && (event.target.tagName === "sl-menu-item" || ((_a = event.target.role) == null ? void 0 : _a.startsWith("menuitem")))) {
+        this.disableSubmenu();
+      }
+    };
+    // Close this submenu on focus outside of the parent or any descendants.
+    this.handleFocusOut = (event) => {
+      if (event.relatedTarget && event.relatedTarget instanceof Element && this.host.contains(event.relatedTarget)) {
+        return;
+      }
+      this.disableSubmenu();
+    };
+    // Prevent the parent menu-item from getting focus on mouse movement on the submenu
+    this.handlePopupMouseover = (event) => {
+      event.stopPropagation();
+    };
+    // Set the safe triangle values for the submenu when the position changes
+    this.handlePopupReposition = () => {
+      const submenuSlot = this.host.renderRoot.querySelector("slot[name='submenu']");
+      const menu = submenuSlot == null ? void 0 : submenuSlot.assignedElements({ flatten: true }).filter((el) => el.localName === "sl-menu")[0];
+      const isRtl = getComputedStyle(this.host).direction === "rtl";
+      if (!menu) {
+        return;
+      }
+      const { left, top, width, height } = menu.getBoundingClientRect();
+      this.host.style.setProperty("--safe-triangle-submenu-start-x", `${isRtl ? left + width : left}px`);
+      this.host.style.setProperty("--safe-triangle-submenu-start-y", `${top}px`);
+      this.host.style.setProperty("--safe-triangle-submenu-end-x", `${isRtl ? left + width : left}px`);
+      this.host.style.setProperty("--safe-triangle-submenu-end-y", `${top + height}px`);
+    };
+    (this.host = host).addController(this);
+    this.hasSlotController = hasSlotController;
+  }
+  hostConnected() {
+    if (this.hasSlotController.test("submenu") && !this.host.disabled) {
+      this.addListeners();
+    }
+  }
+  hostDisconnected() {
+    this.removeListeners();
+  }
+  hostUpdated() {
+    if (this.hasSlotController.test("submenu") && !this.host.disabled) {
+      this.addListeners();
+      this.updateSkidding();
+    } else {
+      this.removeListeners();
+    }
+  }
+  addListeners() {
+    if (!this.isConnected) {
+      this.host.addEventListener("mousemove", this.handleMouseMove);
+      this.host.addEventListener("mouseover", this.handleMouseOver);
+      this.host.addEventListener("keydown", this.handleKeyDown);
+      this.host.addEventListener("click", this.handleClick);
+      this.host.addEventListener("focusout", this.handleFocusOut);
+      this.isConnected = true;
+    }
+    if (!this.isPopupConnected) {
+      if (this.popupRef.value) {
+        this.popupRef.value.addEventListener("mouseover", this.handlePopupMouseover);
+        this.popupRef.value.addEventListener("sl-reposition", this.handlePopupReposition);
+        this.isPopupConnected = true;
+      }
+    }
+  }
+  removeListeners() {
+    if (this.isConnected) {
+      this.host.removeEventListener("mousemove", this.handleMouseMove);
+      this.host.removeEventListener("mouseover", this.handleMouseOver);
+      this.host.removeEventListener("keydown", this.handleKeyDown);
+      this.host.removeEventListener("click", this.handleClick);
+      this.host.removeEventListener("focusout", this.handleFocusOut);
+      this.isConnected = false;
+    }
+    if (this.isPopupConnected) {
+      if (this.popupRef.value) {
+        this.popupRef.value.removeEventListener("mouseover", this.handlePopupMouseover);
+        this.popupRef.value.removeEventListener("sl-reposition", this.handlePopupReposition);
+        this.isPopupConnected = false;
+      }
+    }
+  }
+  handleSubmenuEntry(event) {
+    const submenuSlot = this.host.renderRoot.querySelector("slot[name='submenu']");
+    if (!submenuSlot) {
+      console.error("Cannot activate a submenu if no corresponding menuitem can be found.", this);
+      return;
+    }
+    let menuItems = null;
+    for (const elt of submenuSlot.assignedElements()) {
+      menuItems = elt.querySelectorAll("sl-menu-item, [role^='menuitem']");
+      if (menuItems.length !== 0) {
+        break;
+      }
+    }
+    if (!menuItems || menuItems.length === 0) {
+      return;
+    }
+    menuItems[0].setAttribute("tabindex", "0");
+    for (let i = 1; i !== menuItems.length; ++i) {
+      menuItems[i].setAttribute("tabindex", "-1");
+    }
+    if (this.popupRef.value) {
+      event.preventDefault();
+      event.stopPropagation();
+      if (this.popupRef.value.active) {
+        if (menuItems[0] instanceof HTMLElement) {
+          menuItems[0].focus();
+        }
+      } else {
+        this.enableSubmenu(false);
+        this.host.updateComplete.then(() => {
+          if (menuItems[0] instanceof HTMLElement) {
+            menuItems[0].focus();
+          }
+        });
+        this.host.requestUpdate();
+      }
+    }
+  }
+  setSubmenuState(state) {
+    if (this.popupRef.value) {
+      if (this.popupRef.value.active !== state) {
+        this.popupRef.value.active = state;
+        this.host.requestUpdate();
+      }
+    }
+  }
+  // Shows the submenu. Supports disabling the opening delay, e.g. for keyboard events that want to set the focus to the
+  // newly opened menu.
+  enableSubmenu(delay = true) {
+    if (delay) {
+      window.clearTimeout(this.enableSubmenuTimer);
+      this.enableSubmenuTimer = window.setTimeout(() => {
+        this.setSubmenuState(true);
+      }, this.submenuOpenDelay);
+    } else {
+      this.setSubmenuState(true);
+    }
+  }
+  disableSubmenu() {
+    window.clearTimeout(this.enableSubmenuTimer);
+    this.setSubmenuState(false);
+  }
+  // Calculate the space the top of a menu takes-up, for aligning the popup menu-item with the activating element.
+  updateSkidding() {
+    var _a;
+    if (!((_a = this.host.parentElement) == null ? void 0 : _a.computedStyleMap)) {
+      return;
+    }
+    const styleMap = this.host.parentElement.computedStyleMap();
+    const attrs = ["padding-top", "border-top-width", "margin-top"];
+    const skidding = attrs.reduce((accumulator, attr) => {
+      var _a2;
+      const styleValue = (_a2 = styleMap.get(attr)) != null ? _a2 : new CSSUnitValue(0, "px");
+      const unitValue = styleValue instanceof CSSUnitValue ? styleValue : new CSSUnitValue(0, "px");
+      const pxValue = unitValue.to("px");
+      return accumulator - pxValue.value;
+    }, 0);
+    this.skidding = skidding;
+  }
+  isExpanded() {
+    return this.popupRef.value ? this.popupRef.value.active : false;
+  }
+  renderSubmenu() {
+    const isRtl = getComputedStyle(this.host).direction === "rtl";
+    if (!this.isConnected) {
+      return b` <slot name="submenu" hidden></slot> `;
+    }
+    return b`
+      <sl-popup
+        ${n(this.popupRef)}
+        placement=${isRtl ? "left-start" : "right-start"}
+        anchor="anchor"
+        flip
+        flip-fallback-strategy="best-fit"
+        skidding="${this.skidding}"
+        strategy="fixed"
+        auto-size="vertical"
+        auto-size-padding="10"
+      >
+        <slot name="submenu"></slot>
+      </sl-popup>
+    `;
+  }
+};
+
+export {
+  SubmenuController
+};

package/cdn/chunks/chunk.JTVJZDDS.js

@@ -0,0 +1,335 @@
+import {
+  defaultValue
+} from "./chunk.JCJCP52E.js";
+import {
+  FormControlController
+} from "./chunk.SY37VGFH.js";
+import {
+  o
+} from "./chunk.KJQP3AWV.js";
+import {
+  HasSlotController
+} from "./chunk.NYIIDP5N.js";
+import {
+  ShoelaceElement,
+  e,
+  n,
+  r
+} from "./chunk.LFNFCZYE.js";
+import {
+  b
+} from "./chunk.7WSF3BCU.js";
+import {
+  __decorateClass
+} from "./chunk.CZCSAYQZ.js";
+
+// src/internal/picker.ts
+var PickerBase = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.formControlController = new FormControlController(this);
+    this.hasSlotController = new HasSlotController(
+      this,
+      "help-text",
+      "label",
+      "prefix",
+      "suffix",
+      "clear-icon"
+    );
+    this.lastValidValue = "";
+    this.open = false;
+    this.isMobile = false;
+    this.value = "";
+    this.defaultValue = "";
+    this.name = "";
+    this.placeholder = "";
+    this.label = "";
+    this.disabled = false;
+    this.readonly = false;
+    this.clearable = true;
+    this.size = "medium";
+    this.hoist = false;
+    this.filled = false;
+    this.pill = false;
+    this.helpText = "";
+    this.form = "";
+    this.required = false;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.handleResize = this.handleResize.bind(this);
+    window.addEventListener("resize", this.handleResize);
+    this.handleResize();
+    if (!this.value && this.defaultValue) {
+      this.value = this.defaultValue;
+    }
+    const parsedValue = this.parseValue(this.value);
+    if (this.value && (!parsedValue || !this.isValidFormat(this.value))) {
+      this.value = "";
+    } else if (parsedValue) {
+      this.lastValidValue = this.value;
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    window.removeEventListener("resize", this.handleResize);
+  }
+  isValidFormat(value) {
+    return !!value;
+  }
+  isValidValue(date) {
+    return !!date;
+  }
+  getInputType() {
+    return "text";
+  }
+  getInputPattern() {
+    return void 0;
+  }
+  getInputSuffixIconName() {
+    return void 0;
+  }
+  shouldRevertOnBlur(wasOpen) {
+    return false;
+  }
+  handleResize() {
+    this.isMobile = window.matchMedia("(max-width: 500px)").matches;
+  }
+  openCalendar() {
+    if (this.disabled || this.readonly) {
+      return;
+    }
+    if (this.input) {
+      this.input.focus({ preventScroll: true });
+    }
+    if (!this.open) {
+      this.open = !this.open;
+    }
+  }
+  /** 移除焦点并关闭面板 */
+  blur() {
+    if (this.isMobile && this.open) {
+      return;
+    }
+    this.input.blur();
+    this.open = false;
+  }
+  checkValidity() {
+    return this.input.checkValidity();
+  }
+  reportValidity() {
+    return this.input.reportValidity();
+  }
+  setCustomValidity(message) {
+    this.input.setCustomValidity(message);
+    this.formControlController.updateValidity();
+  }
+  getForm() {
+    return this.formControlController.getForm();
+  }
+  get validity() {
+    return this.input.validity;
+  }
+  get validationMessage() {
+    return this.input.validationMessage;
+  }
+  updateValue(value, options) {
+    const oldValue = this.value;
+    this.value = value;
+    if (value !== oldValue) {
+      if (options == null ? void 0 : options.emitInput) {
+        this.emit("sl-input");
+      }
+      if (options == null ? void 0 : options.emitChange) {
+        this.emit("sl-change");
+      }
+    }
+  }
+  handleTriggerMouseDown(event) {
+    const path = event.composedPath();
+    const isIconButton = path.some((el) => el instanceof Element && el.tagName.toLowerCase() === "sl-icon-button");
+    if (isIconButton) {
+      return;
+    }
+    this.openCalendar();
+  }
+  handleSuffixClick() {
+    this.openCalendar();
+  }
+  handleInputChange(event) {
+    event.stopPropagation();
+    const target = event.target;
+    this.updateValue(target.value, { emitInput: true, emitChange: true });
+  }
+  handleInputInput(event) {
+  }
+  // 统一移动端行为：只在确认时提交
+  revertValue() {
+    this.updateValue(this.lastValidValue, { emitInput: true, emitChange: true });
+  }
+  commitValue() {
+    const parsedDate = this.parseValue(this.value);
+    const isValid = this.isValidValue(parsedDate);
+    if (isValid && parsedDate) {
+      const formattedValue = this.formatValue(parsedDate);
+      this.updateValue(formattedValue, { emitChange: true });
+    } else {
+      if (this.value === "") {
+        this.lastValidValue = "";
+      } else {
+        this.updateValue(this.lastValidValue, { emitChange: true });
+      }
+    }
+  }
+  handleMobileCancel() {
+    this.open = false;
+    this.revertValue();
+  }
+  handleMobileClear() {
+    this.value = "";
+    this.updateValue("", { emitInput: true, emitChange: true });
+    this.open = false;
+  }
+  handleMobileConfirm() {
+    this.open = false;
+    this.commitValue();
+  }
+  handleInputBlur() {
+    if (this.isMobile && this.open) {
+      return;
+    }
+    const wasOpen = this.open;
+    this.open = false;
+    if (this.shouldRevertOnBlur(wasOpen)) {
+      this.revertValue();
+      return;
+    }
+    this.commitValue();
+  }
+  syncInputValue() {
+    if (this.input && this.input.value !== this.value) {
+      this.input.value = this.value;
+    }
+  }
+  handleInputKeyDown(event) {
+    if (event.key === "Escape" && this.open) {
+      event.stopPropagation();
+      this.open = false;
+    }
+    if (event.key === "Enter") {
+      this.syncInputValue();
+    }
+  }
+  /** 设置焦点并按需打开面板 */
+  focus(options) {
+    this.input.focus(options);
+    if (!this.isMobile) {
+      this.openCalendar();
+    }
+  }
+  handleInputInvalid(event) {
+    this.formControlController.setValidity(false);
+    this.formControlController.emitInvalidEvent(event);
+  }
+  renderInput(slot = "") {
+    const type = this.getInputType();
+    const pattern = this.getInputPattern();
+    const suffixIcon = this.getInputSuffixIconName();
+    return b`
+      <sl-input
+        part="input"
+        slot=${o(slot || void 0)}
+        size=${this.size}
+        .value=${this.value}
+        default-value=${this.defaultValue}
+        label=${this.label}
+        placeholder=${this.placeholder}
+        help-text=${this.helpText}
+        ?disabled=${this.disabled}
+        ?readonly=${this.readonly || this.isMobile}
+        ?clearable=${this.clearable}
+        clear-hides-suffix
+        ?filled=${this.filled}
+        ?pill=${this.pill}
+        ?required=${this.required}
+        ?autofocus=${this.autofocus}
+        type=${o(type)}
+        pattern=${o(pattern)}
+        autocomplete="off"
+        @mousedown=${this.handleTriggerMouseDown}
+        @sl-change=${this.handleInputChange}
+        @sl-blur=${this.handleInputBlur}
+        @sl-input=${this.handleInputInput}
+        @sl-invalid=${this.handleInputInvalid}
+        @keydown=${this.handleInputKeyDown}
+      >
+        ${this.hasSlotController.test("label") ? b`<slot name="label" slot="label"></slot>` : ""}
+        ${this.hasSlotController.test("prefix") ? b`<slot name="prefix" slot="prefix"></slot>` : ""}
+        ${this.hasSlotController.test("suffix") ? b`<slot name="suffix" slot="suffix"></slot>` : suffixIcon ? b`<sl-icon slot="suffix" @click=${this.handleSuffixClick} name=${suffixIcon}></sl-icon>` : ""}
+        ${this.hasSlotController.test("clear-icon") ? b`<slot name="clear-icon" slot="clear-icon"></slot>` : ""}
+        ${this.hasSlotController.test("help-text") ? b`<slot name="help-text" slot="help-text"></slot>` : ""}
+      </sl-input>
+    `;
+  }
+};
+__decorateClass([
+  e("sl-input")
+], PickerBase.prototype, "input", 2);
+__decorateClass([
+  r()
+], PickerBase.prototype, "open", 2);
+__decorateClass([
+  r()
+], PickerBase.prototype, "isMobile", 2);
+__decorateClass([
+  n()
+], PickerBase.prototype, "value", 2);
+__decorateClass([
+  defaultValue()
+], PickerBase.prototype, "defaultValue", 2);
+__decorateClass([
+  n()
+], PickerBase.prototype, "name", 2);
+__decorateClass([
+  n()
+], PickerBase.prototype, "placeholder", 2);
+__decorateClass([
+  n()
+], PickerBase.prototype, "label", 2);
+__decorateClass([
+  n({ type: Boolean })
+], PickerBase.prototype, "disabled", 2);
+__decorateClass([
+  n({ type: Boolean })
+], PickerBase.prototype, "readonly", 2);
+__decorateClass([
+  n({ type: Boolean })
+], PickerBase.prototype, "clearable", 2);
+__decorateClass([
+  n({ reflect: true })
+], PickerBase.prototype, "size", 2);
+__decorateClass([
+  n({ type: Boolean })
+], PickerBase.prototype, "hoist", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], PickerBase.prototype, "filled", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], PickerBase.prototype, "pill", 2);
+__decorateClass([
+  n({ attribute: "help-text" })
+], PickerBase.prototype, "helpText", 2);
+__decorateClass([
+  n({ reflect: true })
+], PickerBase.prototype, "form", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], PickerBase.prototype, "required", 2);
+__decorateClass([
+  n({ type: Boolean })
+], PickerBase.prototype, "autofocus", 2);
+
+export {
+  PickerBase
+};