yuang-framework-ui-pc 1.1.11 → 1.1.12

package/es/ele-dialog/util.js

@@ -0,0 +1,301 @@
+import { unref } from "vue";
+import { queryChild, getCurrentStyle } from "../utils/core";
+import { useMoveEvent } from "../utils/hook";
+const containerClass = "ele-modal-container";
+const wrapperClass = "ele-modal";
+const closedClass = "ele-modal-closed";
+const fixTop = 0.65;
+const fixLeft = 0.65;
+function getModalEl(dialogRef) {
+  var _a, _b;
+  const el = (_b = unref((_a = unref(dialogRef)) == null ? void 0 : _a.dialogContentRef)) == null ? void 0 : _b.$el;
+  return el;
+}
+function initModalStyle(modalEl) {
+  modalEl.style.top = modalEl.offsetTop + "px";
+  modalEl.style.left = modalEl.offsetLeft + "px";
+  modalEl.style.right = "auto";
+  modalEl.style.bottom = "auto";
+  modalEl.style.position = "absolute";
+  modalEl.style.margin = "0";
+}
+function canMoveOut(moveOut, direction) {
+  if (direction && moveOut != null && Array.isArray(moveOut)) {
+    return moveOut.includes(direction);
+  }
+  return false;
+}
+function getModalContainer(inner, multiple, appendTo, modalsEl) {
+  if (multiple) {
+    const parent = (inner ? modalsEl : void 0) || document.body;
+    const wrapper = queryChild(parent, containerClass);
+    if (wrapper) {
+      return wrapper;
+    }
+    const elem = document.createElement("div");
+    elem.classList.add(containerClass);
+    parent.appendChild(elem);
+    return elem;
+  }
+  if (inner && modalsEl) {
+    return modalsEl;
+  }
+  return appendTo || "body";
+}
+function useModalMove(dialogRef, props, isFullscreen) {
+  let modalEl = null;
+  let wrapEl = null;
+  let downOL = null;
+  let downOT = null;
+  const { handleMousedown, handleTouchstart } = useMoveEvent({
+    start: () => {
+      modalEl = getModalEl(dialogRef);
+      wrapEl = modalEl == null ? void 0 : modalEl.parentElement;
+      if (!modalEl || !wrapEl || !props.draggable || isFullscreen.value) {
+        return;
+      }
+      modalEl.style.userSelect = "none";
+      initModalStyle(modalEl);
+      downOL = modalEl.offsetLeft;
+      downOT = modalEl.offsetTop;
+    },
+    move: ({ distanceX, distanceY, e }) => {
+      if (!modalEl || !wrapEl || downOL == null || downOT == null || distanceX == null || distanceY == null) {
+        return;
+      }
+      e.preventDefault();
+      let positionLeft = distanceX + downOL;
+      let positionTop = distanceY + downOT;
+      const limitL = wrapEl.clientWidth - modalEl.clientWidth - fixLeft;
+      const limitT = wrapEl.clientHeight - modalEl.clientHeight - fixTop;
+      if (!props.moveOut) {
+        if (positionLeft < 0) {
+          positionLeft = 0;
+        } else if (positionLeft > limitL) {
+          positionLeft = limitL;
+        }
+        if (positionTop > limitT) {
+          positionTop = limitT;
+        }
+        if (positionTop < 0) {
+          positionTop = 0;
+        }
+      } else {
+        if (!canMoveOut(props.moveOut, "left") && positionLeft < 0) {
+          positionLeft = 0;
+        }
+        if (!canMoveOut(props.moveOut, "right") && positionLeft > limitL) {
+          positionLeft = limitL;
+        }
+        if (!canMoveOut(props.moveOut, "bottom") && positionTop > limitT) {
+          positionTop = limitT;
+        }
+        if (!canMoveOut(props.moveOut, "top") && positionTop < 0) {
+          positionTop = 0;
+        }
+        const minLimitL = wrapEl.clientWidth - 48;
+        if (positionLeft > minLimitL) {
+          positionLeft = minLimitL;
+        }
+        const minLimitT = wrapEl.clientHeight - 48;
+        if (props.multiple && positionTop > minLimitT) {
+          positionTop = minLimitT;
+        }
+      }
+      modalEl.style.left = `${Math.floor(positionLeft)}px`;
+      modalEl.style.top = `${Math.floor(positionTop)}px`;
+    },
+    end: () => {
+      if (modalEl) {
+        modalEl.style.userSelect = "";
+      }
+      downOL = null;
+      downOT = null;
+      modalEl = null;
+      wrapEl = null;
+    },
+    touchmoveOptions: { passive: false }
+  });
+  return {
+    handleHeaderMousedown: handleMousedown,
+    handleHeaderTouchstart: handleTouchstart
+  };
+}
+function useModalResize(dialogRef, props, isFullscreen) {
+  let modalEl = null;
+  let wrapEl = null;
+  let downW = null;
+  let downH = null;
+  const { handleMousedown, handleTouchstart } = useMoveEvent({
+    start: () => {
+      modalEl = getModalEl(dialogRef);
+      wrapEl = modalEl == null ? void 0 : modalEl.parentElement;
+      if (!modalEl || !wrapEl || !props.resizable || isFullscreen.value) {
+        return;
+      }
+      modalEl.style.userSelect = "none";
+      initModalStyle(modalEl);
+      downW = modalEl.clientWidth;
+      downH = modalEl.clientHeight;
+    },
+    move: ({ distanceX, distanceY, e }) => {
+      if (!modalEl || !wrapEl || downW == null || downH == null || distanceX == null || distanceY == null) {
+        return;
+      }
+      e.preventDefault();
+      if (props.resizable !== "vertical") {
+        const w = distanceX + downW;
+        const maxW = wrapEl.clientWidth - modalEl.offsetLeft - fixLeft;
+        const nw = (w < props.minWidth ? props.minWidth : !canMoveOut(props.moveOut, "right") && w > maxW ? maxW : w) + "px";
+        modalEl.style.width = nw;
+        modalEl.style.maxWidth = nw;
+        modalEl.style.minWidth = nw;
+      }
+      if (props.resizable !== "horizontal") {
+        const h = distanceY + downH;
+        const maxH = wrapEl.clientHeight - modalEl.offsetTop - fixTop;
+        const nh = (h < props.minHeight ? props.minHeight : !canMoveOut(props.moveOut, "bottom") && h > maxH ? maxH : h) + "px";
+        modalEl.style.height = nh;
+        modalEl.style.maxHeight = nh;
+        modalEl.style.minHeight = nh;
+      }
+    },
+    end: () => {
+      if (modalEl) {
+        modalEl.style.userSelect = "";
+      }
+      downW = null;
+      downH = null;
+      modalEl = null;
+      wrapEl = null;
+    },
+    touchmoveOptions: { passive: false }
+  });
+  return {
+    handleResizeMousedown: handleMousedown,
+    handleResizeTouchstart: handleTouchstart
+  };
+}
+function useModalEvent(dialogRef, props, isFullscreen) {
+  const { handleHeaderMousedown, handleHeaderTouchstart } = useModalMove(
+    dialogRef,
+    props,
+    isFullscreen
+  );
+  const { handleResizeMousedown, handleResizeTouchstart } = useModalResize(
+    dialogRef,
+    props,
+    isFullscreen
+  );
+  let isInitPosition = true;
+  const getZIndex = () => {
+    return props.zIndex ?? 2e3;
+  };
+  const topModal = (el) => {
+    var _a;
+    const modalEl = el ?? getModalEl(dialogRef);
+    const overlayEl = (_a = modalEl == null ? void 0 : modalEl.parentElement) == null ? void 0 : _a.parentElement;
+    if (!overlayEl) {
+      return;
+    }
+    const currentIndex = getCurrentStyle(overlayEl).zIndex;
+    const containerEl = overlayEl.parentElement;
+    const cls = `.${wrapperClass}:not(.${closedClass})`;
+    const modals = containerEl ? containerEl.querySelectorAll(cls) : void 0;
+    let maxIndex = 0;
+    (modals ? Array.from(modals) : []).forEach((modalEl2) => {
+      const zIndex = getCurrentStyle(modalEl2).zIndex;
+      if (zIndex != null) {
+        const index = Number(zIndex);
+        if (index >= maxIndex && (!overlayEl || modalEl2 !== overlayEl)) {
+          maxIndex = index + 1;
+        }
+      }
+    });
+    if (maxIndex > Number(currentIndex || getZIndex() || 0)) {
+      overlayEl.style.zIndex = String(maxIndex);
+    }
+  };
+  const mousedownListener = (event) => {
+    if (props.multiple) {
+      topModal(event.currentTarget);
+    }
+  };
+  const bindAutoTopEvent = () => {
+    const modalEl = getModalEl(dialogRef);
+    if (modalEl) {
+      modalEl.addEventListener("mousedown", mousedownListener);
+      modalEl.addEventListener("touchstart", mousedownListener);
+    }
+  };
+  const unbindAutoTopEvent = () => {
+    const modalEl = getModalEl(dialogRef);
+    if (modalEl) {
+      modalEl.removeEventListener("mousedown", mousedownListener);
+      modalEl.removeEventListener("touchstart", mousedownListener);
+    }
+  };
+  const getPositionMargin = (position) => {
+    if (position == null || typeof position !== "object" || position.top == null && position.right == null && position.bottom == null && position.left == null) {
+      return;
+    }
+    return [position.top, position.right, position.bottom, position.left].map((p) => typeof p === "number" ? `${p}px` : p || "auto").join(" ");
+  };
+  const getPosition = () => {
+    if (props.alignCenter) {
+      return "center";
+    }
+    if (props.top != null && props.top !== "") {
+      return { top: props.top };
+    }
+    return props.position;
+  };
+  const setInitPosition = () => {
+    if (isInitPosition) {
+      isInitPosition = false;
+      const modalEl = getModalEl(dialogRef);
+      const margin = getPositionMargin(getPosition());
+      if (modalEl && margin != null) {
+        modalEl.style.margin = margin;
+      }
+    }
+  };
+  const resetModalStyle = () => {
+    const modalEl = getModalEl(dialogRef);
+    if (modalEl) {
+      const w = props.width;
+      modalEl.style.margin = getPositionMargin(getPosition()) || "";
+      modalEl.style.position = "";
+      modalEl.style.top = "";
+      modalEl.style.left = "";
+      modalEl.style.right = "";
+      modalEl.style.bottom = "";
+      modalEl.style.height = "";
+      modalEl.style.maxHeight = "";
+      modalEl.style.minHeight = "";
+      modalEl.style.width = typeof w === "number" ? `${w}px` : w ?? "";
+      modalEl.style.maxWidth = "";
+      modalEl.style.minWidth = "";
+    }
+  };
+  return {
+    handleHeaderMousedown,
+    handleHeaderTouchstart,
+    handleResizeMousedown,
+    handleResizeTouchstart,
+    bindAutoTopEvent,
+    unbindAutoTopEvent,
+    topModal,
+    setInitPosition,
+    resetModalStyle
+  };
+}
+export {
+  closedClass,
+  containerClass,
+  getModalContainer,
+  useModalEvent,
+  useModalMove,
+  useModalResize,
+  wrapperClass
+};

package/lib/ele-dialog/index.cjs

@@ -0,0 +1,341 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const icons = require("../icons");
+const ReceiverView = require("../ele-config-provider/components/receiver-view");
+const util = require("../ele-pro-layout/util");
+const util$1 = require("./util");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleModal",
+  components: {
+    ElDialog: elementPlus.ElDialog,
+    ElIcon: elementPlus.ElIcon,
+    CloseOutlined: icons.CloseOutlined,
+    CompressOutlined: icons.CompressOutlined,
+    ExpandOutlined: icons.ExpandOutlined,
+    ResizeOutlined: icons.ResizeOutlined,
+    ReceiverView
+  },
+  inheritAttrs: false,
+  props: props.modalProps,
+  emits: props.modalEmits,
+  setup(props2, { emit }) {
+    const layoutState = util.useLayoutState();
+    const isResponsive = util.useResponsive(props2);
+    const dialogRef = vue.ref(null);
+    const isFullscreen = vue.ref(props2.fullscreen ?? false);
+    const isActivated = vue.ref(true);
+    const dialogClass = vue.computed(() => {
+      const classes = [util$1.wrapperClass];
+      if (props2.responsive ?? isResponsive.value ?? true) {
+        classes.push("ele-modal-responsive");
+      }
+      if (props2.alignCenter || props2.position === "center") {
+        classes.push("ele-modal-center");
+      } else if (props2.position === "top") {
+        classes.push("ele-modal-top");
+      } else if (props2.position === "bottom") {
+        classes.push("ele-modal-bottom");
+      } else if (props2.position === "left") {
+        classes.push("ele-modal-left");
+      } else if (props2.position === "right") {
+        classes.push("ele-modal-right");
+      } else if (props2.position === "leftTop") {
+        classes.push("ele-modal-left-top");
+      } else if (props2.position === "leftBottom") {
+        classes.push("ele-modal-left-bottom");
+      } else if (props2.position === "rightTop") {
+        classes.push("ele-modal-right-top");
+      } else if (props2.position === "rightBottom") {
+        classes.push("ele-modal-right-bottom");
+      }
+      if (props2.draggable) {
+        classes.push("ele-modal-movable");
+      }
+      if (props2.resizable) {
+        classes.push("ele-modal-resizable");
+      }
+      if (props2.multiple) {
+        classes.push("ele-modal-multiple");
+      }
+      if (isFullscreen.value) {
+        classes.push("ele-modal-fullscreen");
+      }
+      if (!props2.modelValue) {
+        classes.push(util$1.closedClass);
+      }
+      if (!isActivated.value && props2.modelValue) {
+        classes.push("ele-modal-hide");
+      }
+      if (props2.inner) {
+        classes.push("ele-modal-inner");
+      }
+      if (props2.modalClass) {
+        classes.push(props2.modalClass);
+      }
+      return classes.join(" ");
+    });
+    const teleportTo = vue.computed(() => {
+      return util$1.getModalContainer(
+        props2.inner,
+        props2.multiple,
+        props2.appendTo,
+        layoutState.modalsEl
+      );
+    });
+    const teleportDisabled = vue.computed(() => {
+      const appendTo = props2.appendTo || "body";
+      const disabled = appendTo === "body" ? !props2.appendToBody : false;
+      return props2.multiple || props2.inner ? false : disabled;
+    });
+    const {
+      handleHeaderMousedown,
+      handleHeaderTouchstart,
+      handleResizeMousedown,
+      handleResizeTouchstart,
+      bindAutoTopEvent,
+      unbindAutoTopEvent,
+      topModal,
+      setInitPosition,
+      resetModalStyle
+    } = util$1.useModalEvent(dialogRef, props2, isFullscreen);
+    const updateModelValue = (modelValue) => {
+      emit("update:modelValue", modelValue);
+    };
+    const toggleFullscreen = (fullscreen) => {
+      isFullscreen.value = fullscreen ?? !isFullscreen.value;
+      vue.nextTick(() => {
+        topModal();
+      });
+      emit("update:fullscreen", isFullscreen.value);
+    };
+    const handleOpen = () => {
+      if (props2.resetOnClose || props2.destroyOnClose) {
+        isFullscreen.value = props2.fullscreen ?? false;
+      }
+      vue.nextTick(() => {
+        if (props2.resetOnClose) {
+          resetModalStyle();
+        } else {
+          setInitPosition();
+        }
+        topModal();
+      });
+      emit("open");
+    };
+    const handleOpened = () => {
+      bindAutoTopEvent();
+      emit("opened");
+    };
+    const handleClose = () => {
+      unbindAutoTopEvent();
+      emit("close");
+    };
+    const handleClosed = () => {
+      emit("closed");
+    };
+    const handleOpenAutoFocus = () => {
+      emit("openAutoFocus");
+    };
+    const handleCloseAutoFocus = () => {
+      emit("closeAutoFocus");
+    };
+    vue.watch(
+      () => props2.fullscreen,
+      (fullscreen) => {
+        isFullscreen.value = fullscreen ?? false;
+      }
+    );
+    vue.onMounted(() => {
+      if (props2.modelValue) {
+        setInitPosition();
+      }
+    });
+    vue.onActivated(() => {
+      isActivated.value = true;
+    });
+    vue.onDeactivated(() => {
+      isActivated.value = false;
+    });
+    return {
+      dialogRef,
+      isFullscreen,
+      dialogClass,
+      teleportTo,
+      teleportDisabled,
+      handleHeaderMousedown,
+      handleHeaderTouchstart,
+      handleResizeMousedown,
+      handleResizeTouchstart,
+      updateModelValue,
+      toggleFullscreen,
+      handleOpen,
+      handleOpened,
+      handleClose,
+      handleClosed,
+      handleOpenAutoFocus,
+      handleCloseAutoFocus
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CompressOutlined = vue.resolveComponent("CompressOutlined");
+  const _component_ExpandOutlined = vue.resolveComponent("ExpandOutlined");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_CloseOutlined = vue.resolveComponent("CloseOutlined");
+  const _component_ResizeOutlined = vue.resolveComponent("ResizeOutlined");
+  const _component_ReceiverView = vue.resolveComponent("ReceiverView");
+  const _component_ElDialog = vue.resolveComponent("ElDialog");
+  return vue.openBlock(), vue.createBlock(vue.Teleport, {
+    to: _ctx.teleportTo,
+    disabled: _ctx.teleportDisabled
+  }, [
+    vue.createVNode(_component_ElDialog, vue.mergeProps(_ctx.$attrs, {
+      ref: "dialogRef",
+      modelValue: _ctx.modelValue,
+      title: _ctx.title,
+      width: _ctx.width,
+      fullscreen: false,
+      modal: _ctx.multiple ? false : _ctx.modal,
+      modalClass: _ctx.dialogClass,
+      appendToBody: false,
+      lockScroll: _ctx.inner || _ctx.multiple ? false : _ctx.lockScroll,
+      openDelay: _ctx.openDelay,
+      closeDelay: _ctx.closeDelay,
+      closeOnClickModal: _ctx.closeOnClickModal,
+      closeOnPressEscape: _ctx.closeOnPressEscape,
+      showClose: false,
+      beforeClose: _ctx.beforeClose,
+      draggable: false,
+      overflow: false,
+      center: _ctx.center,
+      alignCenter: false,
+      destroyOnClose: _ctx.destroyOnClose,
+      zIndex: _ctx.zIndex,
+      headerAriaLevel: _ctx.headerAriaLevel,
+      "onUpdate:modelValue": _ctx.updateModelValue,
+      onOpen: _ctx.handleOpen,
+      onOpened: _ctx.handleOpened,
+      onClose: _ctx.handleClose,
+      onClosed: _ctx.handleClosed,
+      onOpenAutoFocus: _ctx.handleOpenAutoFocus,
+      onCloseAutoFocus: _ctx.handleCloseAutoFocus
+    }), vue.createSlots({
+      header: vue.withCtx(({ close, titleId, titleClass }) => [
+        vue.createElementVNode("div", {
+          style: vue.normalizeStyle(_ctx.headerStyle),
+          class: "ele-modal-header",
+          onMousedown: _cache[6] || (_cache[6] = (...args) => _ctx.handleHeaderMousedown && _ctx.handleHeaderMousedown(...args)),
+          onTouchstart: _cache[7] || (_cache[7] = (...args) => _ctx.handleHeaderTouchstart && _ctx.handleHeaderTouchstart(...args))
+        }, [
+          vue.createElementVNode("div", {
+            class: "ele-modal-title",
+            style: vue.normalizeStyle(_ctx.titleStyle)
+          }, [
+            vue.renderSlot(_ctx.$slots, "header", {
+              close,
+              titleId,
+              titleClass
+            }, () => [
+              vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
+            ])
+          ], 4),
+          _ctx.maxable ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            class: "ele-modal-tool ele-modal-tool-max",
+            style: vue.normalizeStyle(_ctx.fullscreenBtnStyle),
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.toggleFullscreen()),
+            onMousedown: _cache[1] || (_cache[1] = vue.withModifiers(() => {
+            }, ["stop"])),
+            onTouchstart: _cache[2] || (_cache[2] = vue.withModifiers(() => {
+            }, ["stop"]))
+          }, [
+            vue.renderSlot(_ctx.$slots, "maxIcon", { fullscreen: _ctx.isFullscreen }, () => [
+              vue.createVNode(_component_ElIcon, null, {
+                default: vue.withCtx(() => [
+                  _ctx.isFullscreen ? (vue.openBlock(), vue.createBlock(_component_CompressOutlined, { key: 0 })) : (vue.openBlock(), vue.createBlock(_component_ExpandOutlined, { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 36)) : vue.createCommentVNode("", true),
+          _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 1,
+            class: "ele-modal-tool",
+            style: vue.normalizeStyle(_ctx.closeBtnStyle),
+            onClick: _cache[3] || (_cache[3] = ($event) => _ctx.updateModelValue(false)),
+            onMousedown: _cache[4] || (_cache[4] = vue.withModifiers(() => {
+            }, ["stop"])),
+            onTouchstart: _cache[5] || (_cache[5] = vue.withModifiers(() => {
+            }, ["stop"]))
+          }, [
+            vue.renderSlot(_ctx.$slots, "closeIcon", {}, () => [
+              vue.createVNode(_component_ElIcon, null, {
+                default: vue.withCtx(() => [
+                  _ctx.closeIcon ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.closeIcon), { key: 0 })) : (vue.openBlock(), vue.createBlock(_component_CloseOutlined, { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 36)) : vue.createCommentVNode("", true)
+        ], 36),
+        _ctx.resizable ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: vue.normalizeClass([
+            "ele-modal-resize-icon",
+            { "is-horizontal": _ctx.resizable === "horizontal" },
+            { "is-vertical": _ctx.resizable === "vertical" }
+          ]),
+          style: vue.normalizeStyle(_ctx.resizeIconStyle),
+          onMousedown: _cache[8] || (_cache[8] = (...args) => _ctx.handleResizeMousedown && _ctx.handleResizeMousedown(...args)),
+          onTouchstart: _cache[9] || (_cache[9] = (...args) => _ctx.handleResizeTouchstart && _ctx.handleResizeTouchstart(...args))
+        }, [
+          vue.renderSlot(_ctx.$slots, "resizeIcon", {}, () => [
+            vue.createVNode(_component_ElIcon, null, {
+              default: vue.withCtx(() => [
+                vue.createVNode(_component_ResizeOutlined)
+              ]),
+              _: 1
+            })
+          ])
+        ], 38)) : vue.createCommentVNode("", true)
+      ]),
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_ReceiverView, {
+          wrapPosition: false,
+          class: vue.normalizeClass(["ele-modal-body", { "is-form": _ctx.form }]),
+          style: vue.normalizeStyle(_ctx.bodyStyle)
+        }, {
+          default: vue.withCtx(() => [
+            vue.renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+        }, 8, ["class", "style"])
+      ]),
+      _: 2
+    }, [
+      _ctx.$slots.footer ? {
+        name: "footer",
+        fn: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            class: "ele-modal-footer",
+            style: vue.normalizeStyle(_ctx.footerStyle)
+          }, [
+            vue.renderSlot(_ctx.$slots, "footer")
+          ], 4)
+        ]),
+        key: "0"
+      } : void 0
+    ]), 1040, ["modelValue", "title", "width", "modal", "modalClass", "lockScroll", "openDelay", "closeDelay", "closeOnClickModal", "closeOnPressEscape", "beforeClose", "center", "destroyOnClose", "zIndex", "headerAriaLevel", "onUpdate:modelValue", "onOpen", "onOpened", "onClose", "onClosed", "onOpenAutoFocus", "onCloseAutoFocus"])
+  ], 8, ["to", "disabled"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;