yuang-framework-ui-pc 1.1.45 → 1.1.46

package/es/ele-pagination/index.js

@@ -0,0 +1,97 @@
+import { defineComponent, computed, resolveComponent, createBlock, openBlock, normalizeClass, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { ElPagination } from "element-plus";
+import { paginationEmits, paginationProps } from "./props";
+const _sfc_main = defineComponent({
+  name: "ElePagination",
+  components: { ElPagination },
+  props: paginationProps,
+  emits: paginationEmits,
+  setup(props, { emit }) {
+    const isInfinite = computed(() => "*" === props.total);
+    const pageTotal = computed(() => {
+      if (isInfinite.value) {
+        if (props.hasNext) {
+          return Number.MAX_SAFE_INTEGER;
+        }
+        return (props.currentPage || 1) * (props.pageSize || 10);
+      }
+      const num = props.total == null ? void 0 : Number(props.total);
+      return num == null || isNaN(num) ? void 0 : num;
+    });
+    const sizesPopperClass = computed(() => {
+      const classes = ["ele-pagination-popper"];
+      if (props.isFixedPopper) {
+        classes.push("is-fixed");
+      }
+      if (typeof props.popperClass === "string" && props.popperClass) {
+        classes.push(props.popperClass);
+      }
+      return classes.join(" ");
+    });
+    const handleUpdateCurrentPage = (currentPage) => {
+      emit("update:currentPage", currentPage);
+    };
+    const handleUpdatePageSize = (pageSize) => {
+      emit("update:pageSize", pageSize);
+    };
+    return {
+      isInfinite,
+      pageTotal,
+      sizesPopperClass,
+      handleUpdateCurrentPage,
+      handleUpdatePageSize
+    };
+  }
+});
+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_ElPagination = resolveComponent("ElPagination");
+  return openBlock(), createBlock(_component_ElPagination, {
+    small: _ctx.small,
+    size: _ctx.size,
+    background: _ctx.type === "circle" ? false : _ctx.background,
+    pageSize: _ctx.pageSize,
+    defaultPageSize: _ctx.defaultPageSize,
+    total: _ctx.pageTotal,
+    pageCount: _ctx.pageCount,
+    pagerCount: _ctx.pagerCount,
+    currentPage: _ctx.currentPage,
+    defaultCurrentPage: _ctx.defaultCurrentPage,
+    layout: _ctx.layout,
+    pageSizes: _ctx.pageSizes,
+    popperClass: _ctx.sizesPopperClass,
+    prevText: _ctx.prevText,
+    prevIcon: _ctx.prevIcon,
+    nextText: _ctx.nextText,
+    nextIcon: _ctx.nextIcon,
+    disabled: _ctx.disabled,
+    teleported: _ctx.teleported,
+    hideOnSinglePage: _ctx.hideOnSinglePage,
+    class: normalizeClass([
+      "ele-pagination",
+      { "is-circle": _ctx.type === "circle" },
+      { "is-infinite": _ctx.isInfinite }
+    ]),
+    "onUpdate:currentPage": _ctx.handleUpdateCurrentPage,
+    "onUpdate:pageSize": _ctx.handleUpdatePageSize
+  }, createSlots({ _: 2 }, [
+    renderList(Object.keys(_ctx.$slots), (name) => {
+      return {
+        name,
+        fn: withCtx((slotProps) => [
+          renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
+        ])
+      };
+    })
+  ]), 1032, ["small", "size", "background", "pageSize", "defaultPageSize", "total", "pageCount", "pagerCount", "currentPage", "defaultCurrentPage", "layout", "pageSizes", "popperClass", "prevText", "prevIcon", "nextText", "nextIcon", "disabled", "teleported", "hideOnSinglePage", "class", "onUpdate:currentPage", "onUpdate:pageSize"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};

package/es/ele-pagination/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 风格
+ */
+export type PaginationType = 'default' | 'circle';
+
+/**
+ * 总条目数
+ */
+export type PaginationTotal = number | '*';

package/es/ele-popconfirm/props.d.ts

@@ -0,0 +1,236 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { StyleValue } from '../ele-app/types';
+import { ElPopconfirmProps, ElIconProps, ElButtonProps } from '../ele-app/el';
+import { ElePopoverProps } from '../ele-app/plus';
+
+/**
+ * 属性
+ */
+export declare const popconfirmProps: {
+    trigger: {
+        type: PropType<ElePopoverProps["trigger"]>;
+        default: string;
+    };
+    /** 确认按钮文字 */
+    confirmButtonText: StringConstructor;
+    /** 取消按钮文字 */
+    cancelButtonText: StringConstructor;
+    /** 确认按钮类型 */
+    confirmButtonType: {
+        type: PropType<ElPopconfirmProps["confirmButtonType"]>;
+        default: string;
+    };
+    /** 取消按钮类型 */
+    cancelButtonType: {
+        type: PropType<ElPopconfirmProps["cancelButtonType"]>;
+        default: string;
+    };
+    /** 自定义图标 */
+    icon: PropType<ElPopconfirmProps["icon"]>;
+    /** 图标颜色 */
+    iconColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** 是否隐藏图标 */
+    hideIcon: BooleanConstructor;
+    /** 是否隐藏确认按钮 */
+    hideConfirmButton: BooleanConstructor;
+    /** 是否隐藏取消按钮 */
+    hideCancelButton: BooleanConstructor;
+    /** 图标样式 */
+    iconStyle: PropType<StyleValue>;
+    /** 图标组件属性 */
+    iconProps: PropType<ElIconProps>;
+    /** 确认按钮组件属性 */
+    confirmButtonProps: PropType<ElButtonProps>;
+    /** 取消按钮组件属性 */
+    cancelButtonProps: PropType<ElButtonProps>;
+    /** 底栏样式 */
+    footerStyle: PropType<StyleValue>;
+    transition: {
+        type: StringConstructor;
+        default: string;
+    };
+    bodyClass: StringConstructor;
+    bodyStyle: PropType<StyleValue>;
+    titleStyle: PropType<StyleValue>;
+    contentStyle: PropType<StyleValue>;
+    showAfter: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 0;
+    };
+    hideAfter: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 200;
+    };
+    autoClose: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 0;
+    };
+    title: StringConstructor;
+    effect: {
+        readonly default: "light";
+        readonly type: PropType<import('element-plus').PopperEffect>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    placement: {
+        readonly type: PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "bottom";
+    };
+    teleported: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    appendTo: {
+        readonly type: PropType<string | HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    offset: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    persistent: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    width: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 150;
+    };
+    visible: {
+        readonly type: PropType<boolean | null>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: null;
+    };
+    triggerKeys: {
+        readonly type: PropType<string[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => string[];
+    };
+    popperOptions: {
+        readonly type: PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {};
+    };
+    tabindex: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 0;
+    };
+    content: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    enterable: {
+        readonly default: true;
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    showArrow: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    popperStyle: PropType<StyleValue>;
+    popperClass: StringConstructor;
+    ariaLabel: StringConstructor;
+    bg: StringConstructor;
+    zIndex: NumberConstructor;
+    arrowOffset: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 5;
+    };
+    virtualRef: {
+        readonly type: PropType<import('element-plus').Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    virtualTriggering: BooleanConstructor;
+    className: StringConstructor;
+    gpuAcceleration: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    arrowBg: StringConstructor;
+};
+export type PopconfirmProps = ExtractPropTypes<typeof popconfirmProps>;
+/**
+ * 事件
+ */
+export declare const popconfirmEmits: {
+    confirm: (_e: MouseEvent) => boolean;
+    cancel: (_e: MouseEvent) => boolean;
+    "update:visible": (value: boolean) => boolean;
+    "before-enter": () => boolean;
+    "before-leave": () => boolean;
+    "after-enter": () => boolean;
+    "after-leave": () => boolean;
+};

package/es/ele-popconfirm/props.js

@@ -0,0 +1,54 @@
+import { popoverProps, popoverEmits } from "../ele-popover/props";
+const popconfirmProps = {
+  ...popoverProps,
+  trigger: {
+    type: String,
+    default: "click"
+  },
+  /** 确认按钮文字 */
+  confirmButtonText: String,
+  /** 取消按钮文字 */
+  cancelButtonText: String,
+  /** 确认按钮类型 */
+  confirmButtonType: {
+    type: String,
+    default: "primary"
+  },
+  /** 取消按钮类型 */
+  cancelButtonType: {
+    type: String,
+    default: "text"
+  },
+  /** 自定义图标 */
+  icon: [String, Object, Function],
+  /** 图标颜色 */
+  iconColor: {
+    type: String,
+    default: "#f90"
+  },
+  /** 是否隐藏图标 */
+  hideIcon: Boolean,
+  /** 是否隐藏确认按钮 */
+  hideConfirmButton: Boolean,
+  /** 是否隐藏取消按钮 */
+  hideCancelButton: Boolean,
+  /** 图标样式 */
+  iconStyle: Object,
+  /** 图标组件属性 */
+  iconProps: Object,
+  /** 确认按钮组件属性 */
+  confirmButtonProps: Object,
+  /** 取消按钮组件属性 */
+  cancelButtonProps: Object,
+  /** 底栏样式 */
+  footerStyle: Object
+};
+const popconfirmEmits = {
+  ...popoverEmits,
+  confirm: (_e) => true,
+  cancel: (_e) => true
+};
+export {
+  popconfirmEmits,
+  popconfirmProps
+};

package/es/ele-popconfirm/style/css-var.scss

@@ -0,0 +1,8 @@
+@use '../../style/util.scss' as *;
+
+/* 气泡确认框主题变量 */
+@mixin set-popconfirm-var($var) {
+  .ele-popconfirm {
+    @include set-ele-var('popconfirm', $var);
+  }
+}

package/es/ele-popconfirm/style/index.scss

@@ -0,0 +1,41 @@
+@use '../../style/themes/default.scss' as *;
+@use '../../style/util.scss' as *;
+@use './css-var.scss' as *;
+
+@include set-popconfirm-var($ele);
+
+.ele-popconfirm > .ele-popover-body {
+  padding: eleVar('popconfirm', 'padding');
+}
+
+.ele-popconfirm-main {
+  display: flex;
+}
+
+.ele-popconfirm-icon {
+  flex-shrink: 0;
+  font-size: eleVar('popconfirm', 'icon-font-size');
+  margin: eleVar('popconfirm', 'icon-margin');
+}
+
+.ele-popconfirm-body {
+  flex: 1;
+}
+
+.ele-popconfirm-title {
+  color: eleVar('popconfirm', 'title-color');
+  font-size: eleVar('popconfirm', 'title-font-size');
+  font-weight: eleVar('popconfirm', 'title-font-weight');
+  margin-bottom: eleVar('popconfirm', 'title-margin');
+}
+
+.ele-popconfirm-action {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  margin-top: eleVar('popconfirm', 'action-margin');
+
+  .el-button + .el-button {
+    margin-left: eleVar('popconfirm', 'action-space');
+  }
+}

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

@@ -0,0 +1,111 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: BooleanConstructor;
+    headerStyle: 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>;
+    title: StringConstructor;
+    margin: (NumberConstructor | StringConstructor)[];
+    direction: import('vue').PropType<import('./types').PrintDirection | null>;
+    orientation: import('vue').PropType<import('./types').PrintOrientation | null>;
+    target: import('vue').PropType<import('./types').PrintTarget | null>;
+    static: BooleanConstructor;
+    options: ObjectConstructor;
+}>, {
+    container: import('vue').ShallowRef<Element, Element>;
+    visible: import('vue').Ref<boolean, boolean>;
+    isStatic: import('vue').ComputedRef<boolean>;
+    print: (options?: any) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:modelValue': (_value: boolean) => boolean;
+    done: () => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: BooleanConstructor;
+    headerStyle: 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>;
+    title: StringConstructor;
+    margin: (NumberConstructor | StringConstructor)[];
+    direction: import('vue').PropType<import('./types').PrintDirection | null>;
+    orientation: import('vue').PropType<import('./types').PrintOrientation | null>;
+    target: import('vue').PropType<import('./types').PrintTarget | null>;
+    static: BooleanConstructor;
+    options: ObjectConstructor;
+}>> & Readonly<{
+    onDone?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: boolean) => any) | undefined;
+}>, {
+    static: boolean;
+    modelValue: boolean;
+}, {}, {
+    ReceiverView: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        wrapPosition: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        authenticated: import('vue').Ref<boolean, boolean>;
+        watermark: string[];
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        wrapPosition: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        wrapPosition: boolean;
+    }, {}, {
+        EleWatermark: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            width: NumberConstructor;
+            height: NumberConstructor;
+            rotate: NumberConstructor;
+            zIndex: NumberConstructor;
+            image: StringConstructor;
+            content: import('vue').PropType<string | string[]>;
+            font: import('vue').PropType<import('../ele-watermark/types').WatermarkFont>;
+            gap: import('vue').PropType<import('../ele-watermark/types').WatermarkGap>;
+            offset: import('vue').PropType<import('../ele-watermark/types').WatermarkOffset>;
+            lineGap: {
+                type: NumberConstructor;
+                default: number;
+            };
+            customStyle: import('vue').PropType<Exclude<import('../ele-app/types').StyleValue, string>>;
+            fixed: BooleanConstructor;
+            wrapPosition: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: BooleanConstructor;
+        }>, {
+            rootKey: import('vue').Ref<number, number>;
+            rootRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+            imgRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+            imgStyle: import('vue').Ref<Partial<import('vue').CSSProperties>, Partial<import('vue').CSSProperties>>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            width: NumberConstructor;
+            height: NumberConstructor;
+            rotate: NumberConstructor;
+            zIndex: NumberConstructor;
+            image: StringConstructor;
+            content: import('vue').PropType<string | string[]>;
+            font: import('vue').PropType<import('../ele-watermark/types').WatermarkFont>;
+            gap: import('vue').PropType<import('../ele-watermark/types').WatermarkGap>;
+            offset: import('vue').PropType<import('../ele-watermark/types').WatermarkOffset>;
+            lineGap: {
+                type: NumberConstructor;
+                default: number;
+            };
+            customStyle: import('vue').PropType<Exclude<import('../ele-app/types').StyleValue, string>>;
+            fixed: BooleanConstructor;
+            wrapPosition: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: BooleanConstructor;
+        }>> & Readonly<{}>, {
+            lineGap: number;
+            fixed: boolean;
+            wrapPosition: boolean;
+            disabled: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/ele-printer/index.js

@@ -0,0 +1,124 @@
+import { defineComponent, ref, shallowRef, computed, watch, onMounted, nextTick, resolveComponent, createBlock, openBlock, Teleport, createElementVNode, normalizeClass, createElementBlock, createCommentVNode, normalizeStyle, renderSlot, createVNode, withCtx } from "vue";
+import ReceiverView from "../ele-config-provider/components/receiver-view";
+import { usePrinter, getPrintContainer, mergeOptions } from "./util";
+import { printerEmits, printerProps } from "./props";
+const _sfc_main = defineComponent({
+  name: "ElePrinter",
+  components: { ReceiverView },
+  props: printerProps,
+  emits: printerEmits,
+  setup(props, { emit }) {
+    const doPrint = usePrinter(() => {
+      visible.value = false;
+      updateModelValue(false);
+      handleDone();
+    });
+    const container = shallowRef(getPrintContainer());
+    const visible = ref(false);
+    const isStatic = computed(() => props.static);
+    const print = (options) => {
+      if (visible.value) {
+        return;
+      }
+      visible.value = true;
+      nextTick(() => {
+        const option = {
+          title: props.title,
+          margin: props.margin,
+          direction: props.direction,
+          orientation: props.orientation,
+          options: mergeOptions(props.options, options)
+        };
+        doPrint(option, props.target);
+      });
+    };
+    const handleDone = () => {
+      emit("done");
+    };
+    const updateModelValue = (value) => {
+      emit("update:modelValue", value);
+    };
+    watch(
+      () => props.modelValue,
+      (modelValue) => {
+        if (modelValue) {
+          print();
+        }
+      }
+    );
+    onMounted(() => {
+      if (props.modelValue) {
+        print();
+      }
+    });
+    return { container, visible, isStatic, print };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = { key: 1 };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ReceiverView = resolveComponent("ReceiverView");
+  return openBlock(), createBlock(Teleport, {
+    to: _ctx.container,
+    disabled: _ctx.isStatic && !_ctx.visible
+  }, [
+    createElementVNode("table", {
+      class: normalizeClass([
+        "ele-printer",
+        { "is-open": _ctx.visible },
+        { "is-static": _ctx.isStatic }
+      ])
+    }, [
+      _ctx.$slots.header ? (openBlock(), createElementBlock("thead", _hoisted_1, [
+        createElementVNode("tr", null, [
+          createElementVNode("td", null, [
+            createElementVNode("div", {
+              class: "ele-printer-header",
+              style: normalizeStyle(_ctx.headerStyle)
+            }, [
+              renderSlot(_ctx.$slots, "header")
+            ], 4)
+          ])
+        ])
+      ])) : createCommentVNode("", true),
+      createElementVNode("tbody", null, [
+        createElementVNode("tr", null, [
+          createElementVNode("td", null, [
+            createVNode(_component_ReceiverView, {
+              class: "ele-printer-body",
+              style: normalizeStyle(_ctx.bodyStyle)
+            }, {
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "default")
+              ]),
+              _: 3
+            }, 8, ["style"])
+          ])
+        ])
+      ]),
+      _ctx.$slots.footer ? (openBlock(), createElementBlock("tfoot", _hoisted_2, [
+        createElementVNode("tr", null, [
+          createElementVNode("td", null, [
+            createElementVNode("div", {
+              class: "ele-printer-footer",
+              style: normalizeStyle(_ctx.footerStyle)
+            }, [
+              renderSlot(_ctx.$slots, "footer")
+            ], 4)
+          ])
+        ])
+      ])) : createCommentVNode("", true)
+    ], 2)
+  ], 8, ["to", "disabled"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};