ele-admin-plus 1.4.1 → 1.5.0-beta.2

package/lib/ele-basic-select/props.cjs

@@ -8,6 +8,12 @@ const basicSelectProps = {
       return null;
     }
   },
+  /** 单选选中展示文本 */
+  selectedLabel: String,
+  /** 多选选中数据 */
+  selected: Array,
+  /** 下拉组件是否显示 */
+  visible: Boolean,
   /** 是否多选 */
   multiple: Boolean,
   /** 是否禁用 */
@@ -18,22 +24,19 @@ const basicSelectProps = {
   clearable: Boolean,
   /** 无选中时提示文本 */
   placeholder: String,
-  /** 单选选中展示文本 */
-  selectedLabel: String,
-  /** 多选选中数据 */
-  selected: Array,
   /** 多选标签最大显示数量 */
   maxTagCount: Number,
   /** 多选标签最大显示文本长度 */
   maxTagTextLength: Number,
   /** 多选标签类型 */
-  tagType: String,
+  tagType: {
+    type: String,
+    default: "info"
+  },
   /** 是否在输入框获得焦点后自动弹出选项菜单 */
   automaticDropdown: Boolean,
   /** 是否可以筛选 */
   filterable: Boolean,
-  /** 下拉组件是否显示 */
-  visible: Boolean,
   /** 自定义类名 */
   selectClass: String,
   /** 自定义样式 */
@@ -49,22 +52,28 @@ const basicSelectProps = {
   /** 下拉组件高度 */
   popperHeight: [Number, String],
   /** 下拉组件类型 */
-  popperType: {
-    type: String,
-    default: "popper"
-  },
+  popperType: String,
   /** 下拉组件属性 */
   popperProps: Object,
-  /** 下拉组件插槽 */
+  /** 下拉组件插槽对应名称 */
   popperSlots: Object,
   /** 下拉组件标题 */
   popperTitle: String,
   /** 是否将下拉组件插入 body */
-  teleported: Boolean,
+  teleported: {
+    type: Boolean,
+    default: true
+  },
   /** 始终渲染下拉组件 */
-  persistent: Boolean,
+  persistent: {
+    type: Boolean,
+    default: true
+  },
   /** 下拉框位置 */
-  placement: String,
+  placement: {
+    type: String,
+    default: "bottom-start"
+  },
   /** 下拉框渐变动画 */
   transition: {
     type: String,

package/lib/ele-basic-select/props.d.ts

@@ -13,6 +13,12 @@ export declare const basicSelectProps: {
         type: PropType<SelectValue>;
         default: () => null;
     };
+    /** 单选选中展示文本 */
+    selectedLabel: StringConstructor;
+    /** 多选选中数据 */
+    selected: PropType<SelectedItem[]>;
+    /** 下拉组件是否显示 */
+    visible: BooleanConstructor;
     /** 是否多选 */
     multiple: BooleanConstructor;
     /** 是否禁用 */
@@ -23,22 +29,19 @@ export declare const basicSelectProps: {
     clearable: BooleanConstructor;
     /** 无选中时提示文本 */
     placeholder: StringConstructor;
-    /** 单选选中展示文本 */
-    selectedLabel: StringConstructor;
-    /** 多选选中数据 */
-    selected: PropType<SelectedItem[]>;
     /** 多选标签最大显示数量 */
     maxTagCount: NumberConstructor;
     /** 多选标签最大显示文本长度 */
     maxTagTextLength: NumberConstructor;
     /** 多选标签类型 */
-    tagType: PropType<ElTagProps["type"]>;
+    tagType: {
+        type: PropType<ElTagProps["type"]>;
+        default: string;
+    };
     /** 是否在输入框获得焦点后自动弹出选项菜单 */
     automaticDropdown: BooleanConstructor;
     /** 是否可以筛选 */
     filterable: BooleanConstructor;
-    /** 下拉组件是否显示 */
-    visible: BooleanConstructor;
     /** 自定义类名 */
     selectClass: StringConstructor;
     /** 自定义样式 */
@@ -54,22 +57,28 @@ export declare const basicSelectProps: {
     /** 下拉组件高度 */
     popperHeight: (NumberConstructor | StringConstructor)[];
     /** 下拉组件类型 */
-    popperType: {
-        type: PropType<PopperType>;
-        default: string;
-    };
+    popperType: PropType<PopperType>;
     /** 下拉组件属性 */
     popperProps: PropType<PopperProps>;
-    /** 下拉组件插槽 */
-    popperSlots: ObjectConstructor;
+    /** 下拉组件插槽对应名称 */
+    popperSlots: PropType<Record<string, string>>;
     /** 下拉组件标题 */
     popperTitle: StringConstructor;
     /** 是否将下拉组件插入 body */
-    teleported: BooleanConstructor;
+    teleported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     /** 始终渲染下拉组件 */
-    persistent: BooleanConstructor;
+    persistent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     /** 下拉框位置 */
-    placement: PropType<EleTooltipProps["placement"]>;
+    placement: {
+        type: PropType<EleTooltipProps["placement"]>;
+        default: string;
+    };
     /** 下拉框渐变动画 */
     transition: {
         type: StringConstructor;

package/lib/ele-basic-select/types.d.ts

@@ -1,3 +1,4 @@
+import type { Ref } from 'vue';
 import type { ComponentProps } from '../ele-app/types';
 import type {
   EleModalProps,
@@ -21,17 +22,17 @@ export type MultipleValue = Array<SingleValue>;
 export type SelectValue = SingleValue | MultipleValue | undefined | null;
 
 /**
- * 多选选中数据
+ * 选中标签数据
  */
 export interface SelectedItem extends Record<string, any> {
   /** 文本 */
   label: string;
   /** 值 */
   value: SingleValue;
-  /** 是否不显示 */
+  /** 原始数据 */
+  data?: any;
+  /** 是否是超出省略时不显示的标签 */
   hide?: boolean;
-  /** 排序号 */
-  index?: number;
 }
 
 /**
@@ -47,3 +48,32 @@ export type PopperProps =
   | EleDrawerProps
   | EleTooltipProps
   | ComponentProps<{}>;
+
+/**
+ * 弹窗模式确认事件钩子
+ */
+export type BeforeConfirm<T> =
+  | ((data?: T) => boolean | undefined | void)
+  | ((data?: T[]) => boolean | undefined | void);
+
+/**
+ * 下拉组件操作选中标签数据
+ */
+export interface SelectDataProvider {
+  /** 选中标签数据 */
+  selectedItems: Ref<SelectedItem[]>;
+  /** 清空选中标签数据 */
+  clearSelectedItems: () => void;
+  /** 移除选中标签项 */
+  removeSelectedItem: (item: SelectedItem) => void;
+  /** 更新选中标签数据 */
+  updateSelectedItems: (items: SelectedItem[]) => void;
+  /** 弹窗模式的临时选中标签数据 */
+  tempSelectedItems: Ref<SelectedItem[]>;
+  /** 弹窗模式清空临时选中标签数据 */
+  clearTempSelectedItems: () => void;
+  /** 弹窗模式移除临时选中标签项 */
+  removeTempSelectedItem: (item: SelectedItem) => void;
+  /** 弹窗模式更新临时选中标签数据 */
+  updateTempSelectedItems: (items: SelectedItem[]) => void;
+}

package/lib/ele-basic-select/util.cjs

@@ -3,9 +3,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue = require("vue");
 const elementPlus = require("element-plus");
 const error = require("element-plus/es/utils/error");
+const SELECT_DATA_KEY = Symbol(
+  "selectData"
+);
 function isEmptyValue(value, multiple) {
-  const isNull = value == null || value === "";
-  return isNull || multiple && !value.length;
+  if (value == null || value === "") {
+    return true;
+  }
+  if (multiple && !value.length) {
+    return true;
+  }
+  return false;
 }
 function valueIsChanged(value1, value2, multiple) {
   const isNull1 = isEmptyValue(value1);
@@ -43,6 +51,7 @@ function useFormValidate() {
   };
   return { validateChange };
 }
+exports.SELECT_DATA_KEY = SELECT_DATA_KEY;
 exports.isEmptyValue = isEmptyValue;
 exports.useFormValidate = useFormValidate;
 exports.valueIsChanged = valueIsChanged;

package/lib/ele-basic-select/util.d.ts

@@ -1,11 +1,16 @@
-import { SelectValue } from '../ele-basic-select/types';
+import { InjectionKey } from 'vue';
+import { SelectValue, SelectDataProvider } from './types';
 
+/**
+ * 下拉组件数据注入键名
+ */
+export declare const SELECT_DATA_KEY: InjectionKey<SelectDataProvider>;
 /**
  * 判断是否是空值
  * @param value 值
  * @param multiple 值是否是数组
  */
-export declare function isEmptyValue(value?: SelectValue, multiple?: boolean): boolean | undefined;
+export declare function isEmptyValue(value?: SelectValue, multiple?: boolean): boolean;
 /**
  * 判断值是否有变化
  * @param value1 新值

package/lib/ele-bottom-bar/index.cjs

@@ -10,8 +10,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     const layoutState = util.useLayoutState();
     const isActivated = vue.ref(true);
     const teleportTo = vue.computed(() => {
-      var _a;
-      return (_a = layoutState.getBodyWrapperEl) == null ? void 0 : _a.call(layoutState);
+      return layoutState.getBodyWrapperEl?.();
     });
     vue.onActivated(() => {
       isActivated.value = true;

package/lib/ele-buttons/components/item-render.cjs

@@ -0,0 +1,224 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const index = require("../../icons/index");
+const common = require("../../utils/common");
+const util = require("../../ele-dropdown-provider/util");
+const util$1 = require("../../ele-popconfirm-provider/util");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "ItemRender" },
+  __name: "item-render",
+  props: {
+    /** 按钮数据 */
+    item: {
+      type: Object,
+      required: true
+    },
+    /** 是否显示分割线 */
+    divider: [Boolean, Object],
+    /** 组件类型 */
+    type: String,
+    /** 是否增加包裹类名 */
+    wrapClass: Boolean,
+    /** 文案 */
+    lang: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: {
+    itemClick: (_command, _e) => true
+  },
+  setup(__props, { emit: __emit }) {
+    const presetIcon = {
+      search: index.SearchOutlined,
+      reset: index.SyncOutlined,
+      add: index.PlusOutlined,
+      delBatch: index.DeleteOutlined,
+      edit: index.EditOutlined,
+      del: index.DeleteOutlined,
+      import: index.UploadOutlined,
+      export: index.DownloadOutlined,
+      upload: index.UploadOutlined,
+      download: index.DownloadOutlined,
+      expand: index.ColumnHeightOutlined,
+      fold: index.VerticalAlignMiddleOutlined,
+      detail: index.EyeOutlined
+    };
+    const dangerLinkPreset = ["del", "delBatch"];
+    const dangerBtnPreset = ["del", "delBatch"];
+    const warningBtnPreset = ["edit"];
+    const defaultBtnPreset = [
+      "reset",
+      "import",
+      "export",
+      "expand",
+      "fold",
+      "detail",
+      "more",
+      "cancel"
+    ];
+    const props = __props;
+    const emit = __emit;
+    const dropdown = util.useDropdown();
+    const popconfirm = util$1.usePopconfirm();
+    const getItemTitle = (item, lang) => {
+      if (item.title != null) {
+        return item.title;
+      }
+      if (!item.preset) {
+        return;
+      }
+      return lang[item.preset];
+    };
+    const getItemIcon = (item) => {
+      if (item.icon != null) {
+        return item.icon;
+      }
+      if (!item.preset) {
+        return;
+      }
+      return presetIcon[item.preset];
+    };
+    const title = vue.computed(() => {
+      return getItemTitle(props.item, props.lang);
+    });
+    const icon = vue.computed(() => {
+      return getItemIcon(props.item);
+    });
+    const linkType = vue.computed(() => {
+      const preset = props.item.preset;
+      if (preset && dangerLinkPreset.includes(preset)) {
+        return "danger";
+      }
+      return "primary";
+    });
+    const btnType = vue.computed(() => {
+      const preset = props.item.preset;
+      if (preset) {
+        if (dangerBtnPreset.includes(preset)) {
+          return "danger";
+        }
+        if (warningBtnPreset.includes(preset)) {
+          return "warning";
+        }
+        if (defaultBtnPreset.includes(preset)) {
+          return "default";
+        }
+      }
+      return "primary";
+    });
+    const triggerItemClick = (command, e) => {
+      emit("itemClick", command, e);
+    };
+    const handleDropdownCommand = (command) => {
+      triggerItemClick(command);
+    };
+    const handleOpenDropdown = (e, item) => {
+      if (!item.dropdownItems || !item.dropdownItems.length || !dropdown || !dropdown.openDropdown) {
+        return;
+      }
+      dropdown.openDropdown(
+        e.currentTarget,
+        common.mapTree(item.dropdownItems, (d) => {
+          return {
+            ...d,
+            title: getItemTitle(d, props.lang),
+            icon: getItemIcon(d)
+          };
+        }),
+        {
+          iconSize: "small",
+          onCommand: handleDropdownCommand,
+          popperOptions: { strategy: "fixed" },
+          ...item.dropdownProps || {},
+          trigger: "hover"
+        }
+      );
+    };
+    const handleOpenPopconfirm = (e, item) => {
+      if (!item.popconfirmProps) {
+        return;
+      }
+      if (!popconfirm || !popconfirm.openPopconfirm) {
+        const onConfirm = item.popconfirmProps.onConfirm;
+        onConfirm && onConfirm(e);
+        return;
+      }
+      popconfirm.openPopconfirm(e.currentTarget, {
+        popperOptions: { strategy: "fixed" },
+        ...item.popconfirmProps || {},
+        trigger: "click"
+      });
+    };
+    const handleItemClick = (e, item) => {
+      if (item.popconfirmProps) {
+        handleOpenPopconfirm(e, item);
+      }
+      item.onClick && item.onClick(e);
+      triggerItemClick(item.command, e);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        __props.divider ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDivider), vue.mergeProps({
+          key: 0,
+          direction: "vertical",
+          class: "ele-buttons-divider"
+        }, typeof __props.divider === "object" ? __props.divider : {}), null, 16)) : vue.createCommentVNode("", true),
+        (__props.item.type ?? __props.type) === "link" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElLink), vue.mergeProps({
+          key: 1,
+          underline: "never",
+          type: linkType.value,
+          icon: icon.value,
+          class: ["ele-buttons-item ele-buttons-link", {
+            "ele-buttons-icon-link": !!icon.value,
+            "ele-buttons-wrap": __props.wrapClass
+          }]
+        }, __props.item.props || {}, {
+          onClick: _cache[0] || (_cache[0] = (e) => handleItemClick(e, __props.item)),
+          onMouseenter: _cache[1] || (_cache[1] = (e) => handleOpenDropdown(e, __props.item))
+        }), {
+          default: vue.withCtx(() => [
+            vue.createElementVNode("span", null, vue.toDisplayString(title.value), 1),
+            __props.item.dropdownItems && __props.item.dropdownItems.length ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElIcon), {
+              key: 0,
+              class: "ele-buttons-arrow"
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(vue.unref(index.ArrowDown))
+              ]),
+              _: 1
+            })) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 16, ["type", "icon", "class"])) : (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), vue.mergeProps({
+          key: 2,
+          type: btnType.value,
+          icon: icon.value,
+          class: ["ele-buttons-item ele-buttons-btn", {
+            "ele-buttons-icon-btn": !!icon.value,
+            "ele-buttons-wrap": __props.wrapClass
+          }]
+        }, __props.item.props || {}, {
+          onClick: _cache[2] || (_cache[2] = (e) => handleItemClick(e, __props.item)),
+          onMouseenter: _cache[3] || (_cache[3] = (e) => handleOpenDropdown(e, __props.item))
+        }), {
+          default: vue.withCtx(() => [
+            vue.createElementVNode("span", null, vue.toDisplayString(title.value), 1),
+            __props.item.dropdownItems && __props.item.dropdownItems.length ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElIcon), {
+              key: 0,
+              class: "ele-buttons-arrow"
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(vue.unref(index.ArrowDown))
+              ]),
+              _: 1
+            })) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 16, ["type", "icon", "class"]))
+      ], 64);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/ele-buttons/components/item-render.d.ts

@@ -0,0 +1,46 @@
+import { PropType } from 'vue';
+import { ElDividerProps } from '../../ele-app/el';
+import { ButtonItem, ButtonItemType, ButtonsLocale } from '../types';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 按钮数据 */
+    item: {
+        type: PropType<ButtonItem>;
+        required: true;
+    };
+    /** 是否显示分割线 */
+    divider: PropType<boolean | ElDividerProps>;
+    /** 组件类型 */
+    type: PropType<ButtonItemType>;
+    /** 是否增加包裹类名 */
+    wrapClass: BooleanConstructor;
+    /** 文案 */
+    lang: {
+        type: PropType<ButtonsLocale>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    itemClick: (_command: any, _e?: MouseEvent | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 按钮数据 */
+    item: {
+        type: PropType<ButtonItem>;
+        required: true;
+    };
+    /** 是否显示分割线 */
+    divider: PropType<boolean | ElDividerProps>;
+    /** 组件类型 */
+    type: PropType<ButtonItemType>;
+    /** 是否增加包裹类名 */
+    wrapClass: BooleanConstructor;
+    /** 文案 */
+    lang: {
+        type: PropType<ButtonsLocale>;
+        required: true;
+    };
+}>> & Readonly<{
+    onItemClick?: ((_command: any, _e?: MouseEvent | undefined) => any) | undefined;
+}>, {
+    wrapClass: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/ele-buttons/index.cjs

@@ -0,0 +1,57 @@
+"use strict";
+const vue = require("vue");
+const receiver = require("../ele-config-provider/receiver");
+const ItemRender = require("./components/item-render");
+const props = require("./props");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "EleButtons" },
+  __name: "index",
+  props: props.buttonsProps,
+  emits: props.buttonsEmits,
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit = __emit;
+    const { lang } = receiver.useLocale("buttons", props2);
+    const handleItemClick = (command, e) => {
+      emit("itemClick", command, e);
+    };
+    return (_ctx, _cache) => {
+      return _ctx.gap != null || _ctx.wrap != null || _ctx.modalFooter ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        class: vue.normalizeClass(["ele-buttons-wrap ele-buttons", {
+          "is-nowrap": _ctx.wrap === false,
+          "is-gap": _ctx.gap != null,
+          "is-modal-footer": _ctx.modalFooter
+        }]),
+        style: vue.normalizeStyle(_ctx.gap == null || _ctx.gap === true ? {} : { gap: `${_ctx.gap || 0}px` })
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.items, (item, index) => {
+          return vue.openBlock(), vue.createBlock(ItemRender, {
+            key: item.key ?? item.command ?? item.title,
+            item,
+            divider: index === 0 ? false : _ctx.divider,
+            type: _ctx.type,
+            wrapClass: false,
+            lang: vue.unref(lang),
+            onItemClick: handleItemClick
+          }, null, 8, ["item", "divider", "type", "lang"]);
+        }), 128)),
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 6)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.items, (item, index) => {
+          return vue.openBlock(), vue.createBlock(ItemRender, {
+            key: item.key ?? item.command ?? item.title,
+            item,
+            divider: index === 0 ? false : _ctx.divider,
+            type: _ctx.type,
+            wrapClass: true,
+            lang: vue.unref(lang),
+            onItemClick: handleItemClick
+          }, null, 8, ["item", "divider", "type", "lang"]);
+        }), 128)),
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 64));
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/ele-buttons/index.d.ts

@@ -0,0 +1,47 @@
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    items: import('vue').PropType<import('./types').ButtonItem[]>;
+    divider: import('vue').PropType<boolean | import('../ele-app/el').ElDividerProps>;
+    type: import('vue').PropType<import('./types').ButtonItemType>;
+    gap: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: null;
+    };
+    wrap: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    modalFooter: BooleanConstructor;
+    locale: import('vue').PropType<Partial<import('./types').ButtonsLocale>>;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    itemClick: (_command: any, _e?: MouseEvent | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    items: import('vue').PropType<import('./types').ButtonItem[]>;
+    divider: import('vue').PropType<boolean | import('../ele-app/el').ElDividerProps>;
+    type: import('vue').PropType<import('./types').ButtonItemType>;
+    gap: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: null;
+    };
+    wrap: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    modalFooter: BooleanConstructor;
+    locale: import('vue').PropType<Partial<import('./types').ButtonsLocale>>;
+}>> & Readonly<{
+    onItemClick?: ((_command: any, _e?: MouseEvent | undefined) => any) | undefined;
+}>, {
+    gap: number | boolean;
+    wrap: boolean;
+    modalFooter: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-buttons/props.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const buttonsProps = {
+  /** 按钮数据 */
+  items: Array,
+  /** 是否显示分割线 */
+  divider: [Boolean, Object],
+  /** 组件类型 */
+  type: String,
+  /** 间距 */
+  gap: {
+    type: [Boolean, Number],
+    default: null
+  },
+  /** 是否自动换行 */
+  wrap: {
+    type: Boolean,
+    default: null
+  },
+  /** 是否是弹窗底栏 */
+  modalFooter: Boolean,
+  /** 国际化 */
+  locale: Object
+};
+const buttonsEmits = {
+  itemClick: (_command, _e) => true
+};
+exports.buttonsEmits = buttonsEmits;
+exports.buttonsProps = buttonsProps;