yuang-framework-ui-pc 1.1.43 → 1.1.45

package/lib/ele-config-provider/receiver.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const props = require("./props");
+const defaultLocale = require("../lang/zh_CN");
+function useReceiver() {
+  return vue.inject(props.CONFIG_KEY, {});
+}
+function useGlobalProps(name) {
+  const globalConfig = useReceiver();
+  return vue.computed(() => globalConfig[name] ?? {});
+}
+function useLocale(name, props2) {
+  const globalConfig = useReceiver();
+  const lang = vue.computed(() => {
+    const temp = globalConfig.locale ?? defaultLocale;
+    if (name) {
+      return Object.assign({}, temp[name] ?? {}, props2 == null ? void 0 : props2.locale);
+    }
+    return temp;
+  });
+  return { lang, globalConfig };
+}
+exports.useGlobalProps = useGlobalProps;
+exports.useLocale = useLocale;
+exports.useReceiver = useReceiver;

package/lib/ele-count-up/props.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const countUpProps = {
+  /** 首次动画延迟时间 */
+  delay: {
+    type: Number,
+    default: 300
+  },
+  /** 结束值 */
+  endVal: {
+    type: Number,
+    required: true
+  },
+  /** 参数配置 */
+  options: Object
+};
+const countUpEmits = {
+  /** 渲染完成事件 */
+  ready: (_instance) => true
+};
+exports.countUpEmits = countUpEmits;
+exports.countUpProps = countUpProps;

package/lib/ele-dropdown/components/pro-dropdown.cjs

@@ -0,0 +1,204 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const icons = require("../../icons");
+const core = require("../../utils/core");
+const EleTooltip = require("../../ele-tooltip/index");
+const props$1 = require("../../ele-tooltip/props");
+const DropdownMenus = require("./dropdown-menus");
+const props = require("../props");
+const _sfc_main = vue.defineComponent({
+  name: "ProDropdown",
+  components: { ElButton: elementPlus.ElButton, ElScrollbar: elementPlus.ElScrollbar, EleTooltip, DropdownMenus },
+  props: {
+    ...props.dropdownProps,
+    /** 当前选中菜单项 */
+    selected: Object
+  },
+  emits: props.dropdownEmits,
+  setup(props2, { emit }) {
+    const tooltipRef = vue.ref(null);
+    const tooltipProps = vue.computed(() => {
+      const options = core.pick(props2, props$1.tooltipPropKeys);
+      options.showAfter = props2.trigger === "hover" ? props2.showTimeout : 0;
+      options.hideAfter = props2.trigger === "hover" ? props2.hideTimeout : 0;
+      options.gpuAcceleration = props2.transition === "el-fade-in-linear";
+      const classes = ["ele-dropdown"];
+      if (props2.preventContextmenu) {
+        classes.push("is-prevent-event");
+      }
+      if (typeof props2.popperClass === "string" && props2.popperClass) {
+        classes.push(props2.popperClass);
+      }
+      options.popperClass = classes.join(" ");
+      options.isPopover = true;
+      return options;
+    });
+    const hasSubMenu = vue.computed(
+      () => !!(props2.items && props2.items.some((d) => {
+        var _a;
+        return !!((_a = d.children) == null ? void 0 : _a.length);
+      }))
+    );
+    const hidePopper = () => {
+      tooltipRef.value && tooltipRef.value.hide();
+    };
+    const updatePopper = () => {
+      tooltipRef.value && tooltipRef.value.updatePopper();
+    };
+    const handleUpdateVisible = (visible) => {
+      emit("update:visible", visible);
+      emit("visibleChange", visible);
+    };
+    const handlePopBeforeEnter = () => {
+      emit("before-enter");
+    };
+    const handlePopBeforeLeave = () => {
+      emit("before-leave");
+    };
+    const handlePopAfterEnter = () => {
+      emit("after-enter");
+    };
+    const handlePopAfterLeave = () => {
+      emit("after-leave");
+    };
+    const handleItemClick = (item) => {
+      var _a;
+      if (props2.hideOnClick && !((_a = item.children) == null ? void 0 : _a.length)) {
+        hidePopper();
+      }
+      emit("command", item.command);
+    };
+    const handleBtnClick = (e) => {
+      emit("click", e);
+    };
+    const handleOpen = () => {
+      if (props2.disabled) {
+        return;
+      }
+      tooltipRef.value && tooltipRef.value.handleOpen();
+    };
+    const handleClose = () => {
+      hidePopper();
+    };
+    const handleWrapperContext = (e) => {
+      if (props2.preventContextmenu) {
+        e.preventDefault();
+      }
+    };
+    return {
+      ArrowDown: icons.ArrowDown,
+      tooltipRef,
+      tooltipProps,
+      hasSubMenu,
+      hidePopper,
+      updatePopper,
+      handleUpdateVisible,
+      handlePopBeforeEnter,
+      handlePopBeforeLeave,
+      handlePopAfterEnter,
+      handlePopAfterLeave,
+      handleItemClick,
+      handleBtnClick,
+      handleOpen,
+      handleClose,
+      handleWrapperContext
+    };
+  }
+});
+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_ElButton = vue.resolveComponent("ElButton");
+  const _component_DropdownMenus = vue.resolveComponent("DropdownMenus");
+  const _component_ElScrollbar = vue.resolveComponent("ElScrollbar");
+  const _component_EleTooltip = vue.resolveComponent("EleTooltip");
+  return vue.openBlock(), vue.createBlock(_component_EleTooltip, vue.mergeProps({ tabindex: _ctx.tabindex }, _ctx.tooltipProps, {
+    ref: "tooltipRef",
+    "onUpdate:visible": _ctx.handleUpdateVisible,
+    onBeforeShow: _ctx.handlePopBeforeEnter,
+    onBeforeHide: _ctx.handlePopBeforeLeave,
+    onShow: _ctx.handlePopAfterEnter,
+    onHide: _ctx.handlePopAfterLeave
+  }), {
+    body: vue.withCtx(() => [
+      _ctx.hasSubMenu ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        class: "ele-dropdown-wrapper",
+        onContextmenu: _cache[0] || (_cache[0] = (...args) => _ctx.handleWrapperContext && _ctx.handleWrapperContext(...args))
+      }, [
+        _ctx.items && _ctx.items.length ? (vue.openBlock(), vue.createBlock(_component_DropdownMenus, {
+          key: 0,
+          role: _ctx.role,
+          items: _ctx.items,
+          selected: _ctx.modelValue,
+          menuStyle: _ctx.menuStyle,
+          iconProps: _ctx.iconProps,
+          size: _ctx.size,
+          onItemClick: _ctx.handleItemClick,
+          onWrapperContext: _ctx.handleWrapperContext
+        }, vue.createSlots({ _: 2 }, [
+          vue.renderList(Object.keys(_ctx.$slots).filter((k) => "default" !== k), (name) => {
+            return {
+              name,
+              fn: vue.withCtx((slotProps) => [
+                vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+              ])
+            };
+          })
+        ]), 1032, ["role", "items", "selected", "menuStyle", "iconProps", "size", "onItemClick", "onWrapperContext"])) : vue.createCommentVNode("", true)
+      ], 32)) : (vue.openBlock(), vue.createBlock(_component_ElScrollbar, {
+        key: 1,
+        maxHeight: _ctx.maxHeight,
+        class: "ele-dropdown-wrapper",
+        onContextmenu: _ctx.handleWrapperContext
+      }, {
+        default: vue.withCtx(() => [
+          _ctx.items && _ctx.items.length ? (vue.openBlock(), vue.createBlock(_component_DropdownMenus, {
+            key: 0,
+            role: _ctx.role,
+            items: _ctx.items,
+            selected: _ctx.modelValue,
+            menuStyle: _ctx.menuStyle,
+            iconProps: _ctx.iconProps,
+            size: _ctx.size,
+            onItemClick: _ctx.handleItemClick,
+            onWrapperContext: _ctx.handleWrapperContext
+          }, vue.createSlots({ _: 2 }, [
+            vue.renderList(Object.keys(_ctx.$slots).filter((k) => "default" !== k), (name) => {
+              return {
+                name,
+                fn: vue.withCtx((slotProps) => [
+                  vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+                ])
+              };
+            })
+          ]), 1032, ["role", "items", "selected", "menuStyle", "iconProps", "size", "onItemClick", "onWrapperContext"])) : vue.createCommentVNode("", true)
+        ]),
+        _: 3
+      }, 8, ["maxHeight", "onContextmenu"]))
+    ]),
+    default: vue.withCtx(() => [
+      _ctx.splitButton ? (vue.openBlock(), vue.createBlock(_component_ElButton, vue.mergeProps({
+        key: 0,
+        type: _ctx.type,
+        size: _ctx.size,
+        disabled: _ctx.disabled,
+        icon: _ctx.ArrowDown,
+        class: "ele-dropdown-caret-button"
+      }, _ctx.caretButtonProps || {}), null, 16, ["type", "size", "disabled", "icon"])) : vue.renderSlot(_ctx.$slots, "default", {
+        key: 1,
+        active: _ctx.modelValue,
+        selected: _ctx.selected
+      })
+    ]),
+    _: 3
+  }, 16, ["tabindex", "onUpdate:visible", "onBeforeShow", "onBeforeHide", "onShow", "onHide"]);
+}
+const proDropdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = proDropdown;

package/lib/ele-dropdown/index.cjs

@@ -0,0 +1,243 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const core = require("../utils/core");
+const util = require("../ele-basic-select/util");
+const ProDropdown = require("./components/pro-dropdown");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleDropdown",
+  components: {
+    ElDropdown: elementPlus.ElDropdown,
+    ElDropdownMenu: elementPlus.ElDropdownMenu,
+    ElDropdownItem: elementPlus.ElDropdownItem,
+    ElButtonGroup: elementPlus.ElButtonGroup,
+    ElButton: elementPlus.ElButton,
+    ElIcon: elementPlus.ElIcon,
+    ProDropdown
+  },
+  props: props.dropdownProps,
+  emits: props.dropdownEmits,
+  setup(props$1, { emit }) {
+    const { validateChange } = util.useFormValidate();
+    const dropdownRef = vue.ref(null);
+    const dropdownProps2 = vue.computed(() => {
+      const options = core.pick(props$1, props.elDropdownPropKeys);
+      const classes = ["ele-popper", "ele-dropdown"];
+      if (props$1.popperClass) {
+        classes.push(props$1.popperClass);
+      }
+      options.popperClass = classes.join(" ");
+      return options;
+    });
+    const selected = vue.computed(() => {
+      if (props$1.modelValue == null || props$1.modelValue === "" || !props$1.items) {
+        return;
+      }
+      return props$1.items.find((d) => d.command === props$1.modelValue);
+    });
+    const updateModelValue = (value) => {
+      if (value !== props$1.modelValue) {
+        emit("update:modelValue", value);
+        validateChange();
+        emit("change", value);
+      }
+    };
+    const handleMenuClick = (command) => {
+      updateModelValue(command);
+      emit("command", command);
+    };
+    const handleBtnClick = (e) => {
+      emit("click", e);
+    };
+    const handlePopVisibleChange = (visible) => {
+      emit("visibleChange", visible);
+    };
+    const handleOpen = () => {
+      if (dropdownRef.value) {
+        dropdownRef.value.handleOpen();
+      }
+    };
+    const handleClose = () => {
+      if (dropdownRef.value) {
+        dropdownRef.value.handleClose();
+      }
+    };
+    const updatePopper = () => {
+      if (dropdownRef.value && dropdownRef.value.updatePopper) {
+        dropdownRef.value.updatePopper();
+      }
+    };
+    return {
+      omit: core.omit,
+      dropdownRef,
+      dropdownProps: dropdownProps2,
+      selected,
+      handleMenuClick,
+      handleBtnClick,
+      handlePopVisibleChange,
+      handleOpen,
+      handleClose,
+      updatePopper
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = {
+  key: 1,
+  class: "ele-dropdown-trigger"
+};
+const _hoisted_2 = { key: 1 };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ProDropdown = vue.resolveComponent("ProDropdown");
+  const _component_ElButton = vue.resolveComponent("ElButton");
+  const _component_ElButtonGroup = vue.resolveComponent("ElButtonGroup");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_ElDropdownItem = vue.resolveComponent("ElDropdownItem");
+  const _component_ElDropdownMenu = vue.resolveComponent("ElDropdownMenu");
+  const _component_ElDropdown = vue.resolveComponent("ElDropdown");
+  return _ctx.componentType === "pro" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+    _ctx.virtualTriggering ? (vue.openBlock(), vue.createBlock(_component_ProDropdown, vue.mergeProps({ key: 0 }, _ctx.$props, {
+      ref: "dropdownRef",
+      splitButton: false,
+      selected: _ctx.selected,
+      onClick: _ctx.handleBtnClick,
+      onCommand: _ctx.handleMenuClick,
+      onVisibleChange: _ctx.handlePopVisibleChange
+    }), vue.createSlots({ _: 2 }, [
+      vue.renderList(Object.keys(_ctx.$slots), (name) => {
+        return {
+          name,
+          fn: vue.withCtx((slotProps) => [
+            vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+          ])
+        };
+      })
+    ]), 1040, ["selected", "onClick", "onCommand", "onVisibleChange"])) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+      _ctx.splitButton ? (vue.openBlock(), vue.createBlock(_component_ElButtonGroup, { key: 0 }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_ElButton, vue.mergeProps({
+            type: _ctx.type,
+            size: _ctx.size,
+            disabled: _ctx.disabled
+          }, _ctx.splitButtonProps || {}, { onClick: _ctx.handleBtnClick }), {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "default", {
+                active: _ctx.modelValue,
+                selected: _ctx.selected
+              })
+            ]),
+            _: 3
+          }, 16, ["type", "size", "disabled", "onClick"]),
+          vue.createVNode(_component_ProDropdown, vue.mergeProps(_ctx.$props, {
+            ref: "dropdownRef",
+            selected: _ctx.selected,
+            onClick: _ctx.handleBtnClick,
+            onCommand: _ctx.handleMenuClick,
+            onVisibleChange: _ctx.handlePopVisibleChange
+          }), vue.createSlots({ _: 2 }, [
+            vue.renderList(Object.keys(_ctx.$slots), (name) => {
+              return {
+                name,
+                fn: vue.withCtx((slotProps) => [
+                  vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+                ])
+              };
+            })
+          ]), 1040, ["selected", "onClick", "onCommand", "onVisibleChange"])
+        ]),
+        _: 3
+      })) : (vue.openBlock(), vue.createBlock(_component_ProDropdown, vue.mergeProps({ key: 1 }, _ctx.$props, {
+        ref: "dropdownRef",
+        selected: _ctx.selected,
+        onClick: _ctx.handleBtnClick,
+        onCommand: _ctx.handleMenuClick,
+        onVisibleChange: _ctx.handlePopVisibleChange
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(Object.keys(_ctx.$slots), (name) => {
+          return {
+            name,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+            ])
+          };
+        })
+      ]), 1040, ["selected", "onClick", "onCommand", "onVisibleChange"]))
+    ]))
+  ], 64)) : (vue.openBlock(), vue.createBlock(_component_ElDropdown, vue.mergeProps({
+    key: 1,
+    class: "ele-dropdown-trigger"
+  }, _ctx.dropdownProps, {
+    ref: "dropdownRef",
+    onClick: _ctx.handleBtnClick,
+    onCommand: _ctx.handleMenuClick,
+    onVisibleChange: _ctx.handlePopVisibleChange
+  }), {
+    dropdown: vue.withCtx(() => [
+      !_ctx.items && _ctx.$slots.dropdown ? vue.renderSlot(_ctx.$slots, "dropdown", { key: 0 }) : (vue.openBlock(), vue.createBlock(_component_ElDropdownMenu, {
+        key: 1,
+        style: vue.normalizeStyle(_ctx.menuStyle)
+      }, {
+        default: vue.withCtx(() => [
+          _ctx.items ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.items, (item) => {
+            return vue.openBlock(), vue.createBlock(_component_ElDropdownItem, vue.mergeProps(
+              {
+                key: item.key == null ? JSON.stringify(item.command) : item.key,
+                class: [
+                  { "is-active": _ctx.modelValue === item.command },
+                  { "is-danger": !!item.danger }
+                ]
+              },
+              { ref_for: true },
+              _ctx.omit(item, [
+                "icon",
+                "title",
+                "iconProps",
+                "iconStyle",
+                "slot",
+                "danger"
+              ])
+            ), {
+              default: vue.withCtx(() => [
+                item.slot && item.slot !== "default" && _ctx.$slots[item.slot] ? vue.renderSlot(_ctx.$slots, item.slot, {
+                  key: 0,
+                  item
+                }) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                  item.icon ? (vue.openBlock(), vue.createBlock(_component_ElIcon, vue.mergeProps({
+                    key: 0,
+                    ref_for: true
+                  }, { ..._ctx.iconProps || {}, ...item.iconProps || {} }), {
+                    default: vue.withCtx(() => [
+                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(item.icon), {
+                        style: vue.normalizeStyle(item.iconStyle)
+                      }, null, 8, ["style"]))
+                    ]),
+                    _: 2
+                  }, 1040)) : vue.createCommentVNode("", true),
+                  item.title ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2, vue.toDisplayString(item.title), 1)) : vue.createCommentVNode("", true)
+                ], 64))
+              ]),
+              _: 2
+            }, 1040, ["class"]);
+          }), 128)) : _ctx.$slots.dropdownMenu ? vue.renderSlot(_ctx.$slots, "dropdownMenu", { key: 1 }) : vue.createCommentVNode("", true)
+        ]),
+        _: 3
+      }, 8, ["style"]))
+    ]),
+    default: vue.withCtx(() => [
+      vue.renderSlot(_ctx.$slots, "default", {
+        active: _ctx.modelValue,
+        selected: _ctx.selected
+      })
+    ]),
+    _: 3
+  }, 16, ["onClick", "onCommand", "onVisibleChange"]));
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

package/lib/ele-file-list/components/file-grid-item.cjs

@@ -0,0 +1,148 @@
+"use strict";
+const vue = require("vue");
+const _sfc_main = vue.defineComponent({
+  name: "FileGridItem",
+  props: {
+    /** 数据 */
+    item: {
+      type: Object,
+      required: true
+    },
+    /** 选择框类型 */
+    selectionType: String,
+    /** 多选选中数据 */
+    selections: Array,
+    /** 单选选中数据 */
+    current: Object,
+    /** 后缀对应的图标 */
+    icons: Array,
+    /** 右键下拉菜单是否显示 */
+    ctxMenuDropdownVisible: Boolean
+  },
+  emits: {
+    click: (_item) => true,
+    checkChange: (_item) => true,
+    contextOpen: (_option) => true
+  },
+  setup(props, { emit }) {
+    const dropdownTriggerRef = vue.ref(null);
+    const selectable = vue.computed(() => {
+      return props.selectionType === "checkbox" || props.selectionType === "radio";
+    });
+    const selected = vue.computed(() => {
+      if (!selectable.value || !props.item) {
+        return false;
+      }
+      if (props.selectionType === "checkbox") {
+        return !!(props.selections && props.selections.some((t) => t.key === props.item.key));
+      }
+      return !!(props.current && props.current.key === props.item.key);
+    });
+    const icon = vue.computed(() => {
+      var _a, _b, _c;
+      if (props.item.thumbnail) {
+        return props.item.thumbnail;
+      }
+      if (!props.icons) {
+        return;
+      }
+      if (props.item.isDirectory) {
+        return (_a = props.icons.find((d) => d.type === "dir")) == null ? void 0 : _a.icon;
+      }
+      if (props.item.name) {
+        const icon2 = (_b = props.icons.find((d) => {
+          if (!d.suffixes) {
+            return false;
+          }
+          return !!d.suffixes.find((t) => !!props.item.name.endsWith(t));
+        })) == null ? void 0 : _b.icon;
+        if (icon2) {
+          return icon2;
+        }
+      }
+      return (_c = props.icons.find((d) => d.type === "file")) == null ? void 0 : _c.icon;
+    });
+    const handleClick = () => {
+      emit("click", props.item);
+    };
+    const handleCheckChange = () => {
+      emit("checkChange", props.item);
+    };
+    const handleContextmenu = (e) => {
+      if (dropdownTriggerRef.value != null) {
+        emit("contextOpen", {
+          item: props.item,
+          triggerEl: dropdownTriggerRef.value,
+          e
+        });
+      }
+    };
+    return {
+      dropdownTriggerRef,
+      selectable,
+      selected,
+      icon,
+      handleClick,
+      handleCheckChange,
+      handleContextmenu
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-file-list-item-icon" };
+const _hoisted_2 = ["src"];
+const _hoisted_3 = ["title"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("div", {
+    class: vue.normalizeClass([
+      "ele-file-list-item",
+      { "is-checked": _ctx.selected },
+      { "is-active": _ctx.ctxMenuDropdownVisible }
+    ]),
+    onClick: _cache[3] || (_cache[3] = vue.withModifiers((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"]))
+  }, [
+    vue.createElementVNode("div", {
+      class: "ele-file-list-item-body",
+      onContextmenu: _cache[0] || (_cache[0] = (...args) => _ctx.handleContextmenu && _ctx.handleContextmenu(...args))
+    }, [
+      vue.createElementVNode("div", _hoisted_1, [
+        vue.renderSlot(_ctx.$slots, "icon", {
+          icon: _ctx.icon,
+          item: _ctx.item
+        }, () => [
+          vue.createElementVNode("img", {
+            src: _ctx.icon,
+            class: vue.normalizeClass({ "ele-file-list-item-image": !!_ctx.item.thumbnail })
+          }, null, 10, _hoisted_2)
+        ])
+      ]),
+      vue.renderSlot(_ctx.$slots, "title", { item: _ctx.item }, () => [
+        vue.createElementVNode("div", {
+          title: _ctx.item.name,
+          class: "ele-file-list-item-title"
+        }, vue.toDisplayString(_ctx.item.name), 9, _hoisted_3)
+      ])
+    ], 32),
+    _ctx.selectable ? (vue.openBlock(), vue.createElementBlock("div", {
+      key: 0,
+      class: "ele-file-list-item-checkbox",
+      onClick: _cache[1] || (_cache[1] = vue.withModifiers((...args) => _ctx.handleCheckChange && _ctx.handleCheckChange(...args), ["stop"]))
+    }, _cache[4] || (_cache[4] = [
+      vue.createElementVNode("i", { class: "ele-file-list-checkbox is-checked" }, null, -1)
+    ]))) : vue.createCommentVNode("", true),
+    vue.createElementVNode("div", {
+      ref: "dropdownTriggerRef",
+      class: "ele-file-list-item-dropdown",
+      onClick: _cache[2] || (_cache[2] = vue.withModifiers(() => {
+      }, ["stop"]))
+    }, null, 512)
+  ], 2);
+}
+const fileGridItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = fileGridItem;