yuang-framework-ui-pc 1.1.10 → 1.1.12

package/es/ele-dialog/index.d.ts

@@ -0,0 +1,245 @@
+import { ElDialogInstance } from '../ele-app/el';
+
+declare const _default: import('vue').DefineComponent<{
+    appendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveOut: import('vue').PropType<import('./types').MoveOut>;
+    resizable: import('vue').PropType<import('./types').Resizable>;
+    position: import('vue').PropType<import('./types').Position>;
+    resetOnClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxable: BooleanConstructor;
+    multiple: BooleanConstructor;
+    inner: BooleanConstructor;
+    minWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    headerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    titleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    footerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    closeBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    fullscreenBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    resizeIconStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    responsive: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    form: BooleanConstructor;
+    appendTo: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, "body", boolean>;
+    beforeClose: {
+        readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    destroyOnClose: BooleanConstructor;
+    closeOnClickModal: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    closeOnPressEscape: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    lockScroll: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    modal: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    openDelay: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    closeDelay: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    top: {
+        readonly type: import('vue').PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    modelValue: BooleanConstructor;
+    modalClass: StringConstructor;
+    width: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    zIndex: {
+        readonly type: import('vue').PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    trapFocus: BooleanConstructor;
+    headerAriaLevel: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    center: BooleanConstructor;
+    alignCenter: BooleanConstructor;
+    closeIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    overflow: BooleanConstructor;
+    fullscreen: BooleanConstructor;
+    showClose: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    title: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    ariaLevel: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}, {
+    dialogRef: import('vue').Ref<ElDialogInstance>;
+    isFullscreen: import('vue').Ref<boolean>;
+    dialogClass: import('vue').ComputedRef<string>;
+    teleportTo: import('vue').ComputedRef<string | Element>;
+    teleportDisabled: import('vue').ComputedRef<boolean>;
+    handleHeaderMousedown: (e: MouseEvent) => void;
+    handleHeaderTouchstart: (e: TouchEvent) => void;
+    handleResizeMousedown: (e: MouseEvent) => void;
+    handleResizeTouchstart: (e: TouchEvent) => void;
+    updateModelValue: (modelValue: boolean) => void;
+    toggleFullscreen: (fullscreen?: boolean) => void;
+    handleOpen: () => void;
+    handleOpened: () => void;
+    handleClose: () => void;
+    handleClosed: () => void;
+    handleOpenAutoFocus: () => void;
+    handleCloseAutoFocus: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:fullscreen': (_fullscreen: boolean) => boolean;
+    open: () => boolean;
+    opened: () => boolean;
+    close: () => boolean;
+    closed: () => boolean;
+    "update:modelValue": (value: boolean) => boolean;
+    openAutoFocus: () => boolean;
+    closeAutoFocus: () => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    appendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    moveOut: import('vue').PropType<import('./types').MoveOut>;
+    resizable: import('vue').PropType<import('./types').Resizable>;
+    position: import('vue').PropType<import('./types').Position>;
+    resetOnClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxable: BooleanConstructor;
+    multiple: BooleanConstructor;
+    inner: BooleanConstructor;
+    minWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    headerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    titleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    footerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    closeBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    fullscreenBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    resizeIconStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    responsive: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    form: BooleanConstructor;
+    appendTo: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown, "body", boolean>;
+    beforeClose: {
+        readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    destroyOnClose: BooleanConstructor;
+    closeOnClickModal: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    closeOnPressEscape: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    lockScroll: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    modal: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    openDelay: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    closeDelay: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    top: {
+        readonly type: import('vue').PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    modelValue: BooleanConstructor;
+    modalClass: StringConstructor;
+    width: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    zIndex: {
+        readonly type: import('vue').PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    trapFocus: BooleanConstructor;
+    headerAriaLevel: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    center: BooleanConstructor;
+    alignCenter: BooleanConstructor;
+    closeIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    overflow: BooleanConstructor;
+    fullscreen: BooleanConstructor;
+    showClose: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    title: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    ariaLevel: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}>> & {
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOpenAutoFocus?: (() => any) | undefined;
+    onCloseAutoFocus?: (() => any) | undefined;
+    "onUpdate:fullscreen"?: ((_fullscreen: boolean) => any) | undefined;
+}, {
+    form: boolean;
+    title: string;
+    center: boolean;
+    modelValue: boolean;
+    appendToBody: boolean;
+    appendTo: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>;
+    destroyOnClose: boolean;
+    closeOnClickModal: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    closeOnPressEscape: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    lockScroll: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    modal: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    openDelay: number;
+    closeDelay: number;
+    trapFocus: boolean;
+    headerAriaLevel: string;
+    alignCenter: boolean;
+    draggable: boolean;
+    overflow: boolean;
+    fullscreen: boolean;
+    showClose: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    ariaLevel: string;
+    minWidth: number;
+    minHeight: number;
+    multiple: boolean;
+    responsive: boolean;
+    resetOnClose: boolean;
+    maxable: boolean;
+    inner: boolean;
+}, {}>;
+export default _default;

package/es/ele-dialog/index.js

@@ -0,0 +1,342 @@
+import { defineComponent, ref, computed, watch, onMounted, onActivated, onDeactivated, nextTick, resolveComponent, openBlock, createBlock, Teleport, createVNode, mergeProps, createSlots, withCtx, createElementVNode, normalizeStyle, renderSlot, createTextVNode, toDisplayString, createElementBlock, withModifiers, createCommentVNode, resolveDynamicComponent, normalizeClass } from "vue";
+import { ElDialog, ElIcon } from "element-plus";
+import { CloseOutlined, CompressOutlined, ExpandOutlined, ResizeOutlined } from "../icons";
+import ReceiverView from "../ele-config-provider/components/receiver-view";
+import { useLayoutState, useResponsive } from "../ele-pro-layout/util";
+import { getModalContainer, useModalEvent, wrapperClass, closedClass } from "./util";
+import { modalProps, modalEmits } from "./props";
+const _sfc_main = defineComponent({
+  name: "EleModal",
+  components: {
+    ElDialog,
+    ElIcon,
+    CloseOutlined,
+    CompressOutlined,
+    ExpandOutlined,
+    ResizeOutlined,
+    ReceiverView
+  },
+  inheritAttrs: false,
+  props: modalProps,
+  emits: modalEmits,
+  setup(props, { emit }) {
+    const layoutState = useLayoutState();
+    const isResponsive = useResponsive(props);
+    const dialogRef = ref(null);
+    const isFullscreen = ref(props.fullscreen ?? false);
+    const isActivated = ref(true);
+    const dialogClass = computed(() => {
+      const classes = [wrapperClass];
+      if (props.responsive ?? isResponsive.value ?? true) {
+        classes.push("ele-modal-responsive");
+      }
+      if (props.alignCenter || props.position === "center") {
+        classes.push("ele-modal-center");
+      } else if (props.position === "top") {
+        classes.push("ele-modal-top");
+      } else if (props.position === "bottom") {
+        classes.push("ele-modal-bottom");
+      } else if (props.position === "left") {
+        classes.push("ele-modal-left");
+      } else if (props.position === "right") {
+        classes.push("ele-modal-right");
+      } else if (props.position === "leftTop") {
+        classes.push("ele-modal-left-top");
+      } else if (props.position === "leftBottom") {
+        classes.push("ele-modal-left-bottom");
+      } else if (props.position === "rightTop") {
+        classes.push("ele-modal-right-top");
+      } else if (props.position === "rightBottom") {
+        classes.push("ele-modal-right-bottom");
+      }
+      if (props.draggable) {
+        classes.push("ele-modal-movable");
+      }
+      if (props.resizable) {
+        classes.push("ele-modal-resizable");
+      }
+      if (props.multiple) {
+        classes.push("ele-modal-multiple");
+      }
+      if (isFullscreen.value) {
+        classes.push("ele-modal-fullscreen");
+      }
+      if (!props.modelValue) {
+        classes.push(closedClass);
+      }
+      if (!isActivated.value && props.modelValue) {
+        classes.push("ele-modal-hide");
+      }
+      if (props.inner) {
+        classes.push("ele-modal-inner");
+      }
+      if (props.modalClass) {
+        classes.push(props.modalClass);
+      }
+      return classes.join(" ");
+    });
+    const teleportTo = computed(() => {
+      return getModalContainer(
+        props.inner,
+        props.multiple,
+        props.appendTo,
+        layoutState.modalsEl
+      );
+    });
+    const teleportDisabled = computed(() => {
+      const appendTo = props.appendTo || "body";
+      const disabled = appendTo === "body" ? !props.appendToBody : false;
+      return props.multiple || props.inner ? false : disabled;
+    });
+    const {
+      handleHeaderMousedown,
+      handleHeaderTouchstart,
+      handleResizeMousedown,
+      handleResizeTouchstart,
+      bindAutoTopEvent,
+      unbindAutoTopEvent,
+      topModal,
+      setInitPosition,
+      resetModalStyle
+    } = useModalEvent(dialogRef, props, isFullscreen);
+    const updateModelValue = (modelValue) => {
+      emit("update:modelValue", modelValue);
+    };
+    const toggleFullscreen = (fullscreen) => {
+      isFullscreen.value = fullscreen ?? !isFullscreen.value;
+      nextTick(() => {
+        topModal();
+      });
+      emit("update:fullscreen", isFullscreen.value);
+    };
+    const handleOpen = () => {
+      if (props.resetOnClose || props.destroyOnClose) {
+        isFullscreen.value = props.fullscreen ?? false;
+      }
+      nextTick(() => {
+        if (props.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");
+    };
+    watch(
+      () => props.fullscreen,
+      (fullscreen) => {
+        isFullscreen.value = fullscreen ?? false;
+      }
+    );
+    onMounted(() => {
+      if (props.modelValue) {
+        setInitPosition();
+      }
+    });
+    onActivated(() => {
+      isActivated.value = true;
+    });
+    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, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CompressOutlined = resolveComponent("CompressOutlined");
+  const _component_ExpandOutlined = resolveComponent("ExpandOutlined");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_CloseOutlined = resolveComponent("CloseOutlined");
+  const _component_ResizeOutlined = resolveComponent("ResizeOutlined");
+  const _component_ReceiverView = resolveComponent("ReceiverView");
+  const _component_ElDialog = resolveComponent("ElDialog");
+  return openBlock(), createBlock(Teleport, {
+    to: _ctx.teleportTo,
+    disabled: _ctx.teleportDisabled
+  }, [
+    createVNode(_component_ElDialog, 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
+    }), createSlots({
+      header: withCtx(({ close, titleId, titleClass }) => [
+        createElementVNode("div", {
+          style: 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))
+        }, [
+          createElementVNode("div", {
+            class: "ele-modal-title",
+            style: normalizeStyle(_ctx.titleStyle)
+          }, [
+            renderSlot(_ctx.$slots, "header", {
+              close,
+              titleId,
+              titleClass
+            }, () => [
+              createTextVNode(toDisplayString(_ctx.title), 1)
+            ])
+          ], 4),
+          _ctx.maxable ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: "ele-modal-tool ele-modal-tool-max",
+            style: normalizeStyle(_ctx.fullscreenBtnStyle),
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.toggleFullscreen()),
+            onMousedown: _cache[1] || (_cache[1] = withModifiers(() => {
+            }, ["stop"])),
+            onTouchstart: _cache[2] || (_cache[2] = withModifiers(() => {
+            }, ["stop"]))
+          }, [
+            renderSlot(_ctx.$slots, "maxIcon", { fullscreen: _ctx.isFullscreen }, () => [
+              createVNode(_component_ElIcon, null, {
+                default: withCtx(() => [
+                  _ctx.isFullscreen ? (openBlock(), createBlock(_component_CompressOutlined, { key: 0 })) : (openBlock(), createBlock(_component_ExpandOutlined, { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 36)) : createCommentVNode("", true),
+          _ctx.showClose ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            class: "ele-modal-tool",
+            style: normalizeStyle(_ctx.closeBtnStyle),
+            onClick: _cache[3] || (_cache[3] = ($event) => _ctx.updateModelValue(false)),
+            onMousedown: _cache[4] || (_cache[4] = withModifiers(() => {
+            }, ["stop"])),
+            onTouchstart: _cache[5] || (_cache[5] = withModifiers(() => {
+            }, ["stop"]))
+          }, [
+            renderSlot(_ctx.$slots, "closeIcon", {}, () => [
+              createVNode(_component_ElIcon, null, {
+                default: withCtx(() => [
+                  _ctx.closeIcon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.closeIcon), { key: 0 })) : (openBlock(), createBlock(_component_CloseOutlined, { key: 1 }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 36)) : createCommentVNode("", true)
+        ], 36),
+        _ctx.resizable ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: normalizeClass([
+            "ele-modal-resize-icon",
+            { "is-horizontal": _ctx.resizable === "horizontal" },
+            { "is-vertical": _ctx.resizable === "vertical" }
+          ]),
+          style: 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))
+        }, [
+          renderSlot(_ctx.$slots, "resizeIcon", {}, () => [
+            createVNode(_component_ElIcon, null, {
+              default: withCtx(() => [
+                createVNode(_component_ResizeOutlined)
+              ]),
+              _: 1
+            })
+          ])
+        ], 38)) : createCommentVNode("", true)
+      ]),
+      default: withCtx(() => [
+        createVNode(_component_ReceiverView, {
+          wrapPosition: false,
+          class: normalizeClass(["ele-modal-body", { "is-form": _ctx.form }]),
+          style: normalizeStyle(_ctx.bodyStyle)
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+        }, 8, ["class", "style"])
+      ]),
+      _: 2
+    }, [
+      _ctx.$slots.footer ? {
+        name: "footer",
+        fn: withCtx(() => [
+          createElementVNode("div", {
+            class: "ele-modal-footer",
+            style: normalizeStyle(_ctx.footerStyle)
+          }, [
+            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]]);
+export {
+  index as default
+};