yuang-framework-ui-pc 1.1.44 → 1.1.46

package/lib/ele-edit-tag/props.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const editTagProps = {
+  /** 标签数据 */
+  modelValue: Array,
+  /** 类型 */
+  type: String,
+  /** 是否有边框描边 */
+  hit: Boolean,
+  /** 颜色 */
+  color: String,
+  /** 尺寸 */
+  size: String,
+  /** 主题 */
+  effect: String,
+  /** 是否为圆形 */
+  round: Boolean,
+  /** 提示文本 */
+  placeholder: String,
+  /** 输入框样式 */
+  inputStyle: Object,
+  /** 输入框外层标签样式 */
+  inputTagStyle: Object,
+  /** 添加按钮样式 */
+  buttonStyle: Object,
+  /** 标签样式 */
+  itemStyle: Object,
+  /** 添加校验方法 */
+  validator: Function,
+  /** 移除校验方法 */
+  beforeRemove: Function,
+  /** 提示属性 */
+  tooltipProps: Object,
+  /** 是否只读 */
+  readonly: Boolean,
+  /** 是否禁用 */
+  disabled: Boolean
+};
+const editTagEmits = {
+  /** 更新数据 */
+  "update:modelValue": (_value) => true,
+  /** 数据改变事件 */
+  change: (_value) => true
+};
+exports.editTagEmits = editTagEmits;
+exports.editTagProps = editTagProps;

package/lib/ele-edit-tag/style/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+require("element-plus/es/components/tag/style/index");
+require("element-plus/es/components/input/style/index");
+require("element-plus/es/components/icon/style/index");
+require("../../ele-tooltip/style/index");
+require("./index.scss");

package/lib/ele-ellipsis/props.d.ts

@@ -0,0 +1,33 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { EllipsisTooltip } from './types';
+
+/**
+ * 属性
+ */
+export declare const ellipsisProps: {
+    /** 最大行数 */
+    maxLine: NumberConstructor;
+    /** 行高 */
+    lineHeight: (NumberConstructor | StringConstructor)[];
+    /** 文字提示属性 */
+    tooltip: {
+        type: PropType<boolean | EllipsisTooltip>;
+        default: () => {
+            original: boolean;
+        };
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: PropType<import('../ele-text/types').TextType>;
+    size: PropType<import('../ele-text/types').TextSize>;
+    deleted: BooleanConstructor;
+    underline: BooleanConstructor;
+    strong: BooleanConstructor;
+    italic: BooleanConstructor;
+    icon: PropType<import('../ele-text/types').TextIcon>;
+    iconProps: PropType<import('../ele-app/el').ElIconProps>;
+    iconStyle: PropType<import('../ele-app/types').StyleValue>;
+};
+export type EllipsisProps = ExtractPropTypes<typeof ellipsisProps>;

package/lib/ele-ellipsis/style/index.d.ts

@@ -0,0 +1 @@
+

package/lib/ele-ellipsis/style/index.scss

@@ -0,0 +1,27 @@
+.ele-ellipsis {
+  overflow: hidden;
+  word-break: break-all;
+
+  &.is-multi-line {
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+  }
+
+  &:not(.is-multi-line) {
+    white-space: nowrap;
+    text-overflow: ellipsis;
+
+    /* 链接支持单行省略 */
+    & > .el-link {
+      display: inline;
+
+      & > .el-link__inner {
+        display: inline;
+      }
+
+      & > .el-icon {
+        vertical-align: -1.7px;
+      }
+    }
+  }
+}

package/lib/ele-ellipsis/types.d.ts

@@ -0,0 +1,9 @@
+import type { EleTooltipProps } from '../ele-app/plus';
+
+/**
+ * 文字提示属性
+ */
+export interface EllipsisTooltip extends EleTooltipProps {
+  /** 是否使用原生的提示 */
+  original?: boolean;
+}

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;

package/lib/ele-file-list/components/file-grid-item.d.ts

@@ -0,0 +1,55 @@
+import { PropType } from 'vue';
+import { IconItem, FileItem, SelectionType, ContextOpenOption } from '../types';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 数据 */
+    item: {
+        type: PropType<FileItem>;
+        required: true;
+    };
+    /** 选择框类型 */
+    selectionType: PropType<SelectionType>;
+    /** 多选选中数据 */
+    selections: PropType<FileItem[]>;
+    /** 单选选中数据 */
+    current: PropType<FileItem>;
+    /** 后缀对应的图标 */
+    icons: PropType<IconItem[]>;
+    /** 右键下拉菜单是否显示 */
+    ctxMenuDropdownVisible: BooleanConstructor;
+}>, {
+    dropdownTriggerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    selectable: import('vue').ComputedRef<boolean>;
+    selected: import('vue').ComputedRef<boolean>;
+    icon: import('vue').ComputedRef<string | undefined>;
+    handleClick: () => void;
+    handleCheckChange: () => void;
+    handleContextmenu: (e: MouseEvent) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (_item: FileItem) => true;
+    checkChange: (_item: FileItem) => true;
+    contextOpen: (_option: ContextOpenOption) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 数据 */
+    item: {
+        type: PropType<FileItem>;
+        required: true;
+    };
+    /** 选择框类型 */
+    selectionType: PropType<SelectionType>;
+    /** 多选选中数据 */
+    selections: PropType<FileItem[]>;
+    /** 单选选中数据 */
+    current: PropType<FileItem>;
+    /** 后缀对应的图标 */
+    icons: PropType<IconItem[]>;
+    /** 右键下拉菜单是否显示 */
+    ctxMenuDropdownVisible: BooleanConstructor;
+}>> & Readonly<{
+    onClick?: ((_item: FileItem) => any) | undefined;
+    onCheckChange?: ((_item: FileItem) => any) | undefined;
+    onContextOpen?: ((_option: ContextOpenOption) => any) | undefined;
+}>, {
+    ctxMenuDropdownVisible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,134 @@
+"use strict";
+const vue = require("vue");
+const ReceiverView = require("../../ele-config-provider/components/receiver-view");
+const FileGridItem = require("./file-grid-item");
+const _sfc_main = vue.defineComponent({
+  name: "FileGrid",
+  components: { ReceiverView, FileGridItem },
+  props: {
+    /** 文件数据 */
+    data: Array,
+    /** 后缀对应的图标 */
+    icons: Array,
+    /** 选择框类型 */
+    selectionType: String,
+    /** 已选中的数据 */
+    selections: Array,
+    /** 单选选中数据 */
+    current: Object,
+    /** 是否是全选 */
+    isCheckAll: Boolean,
+    /** 是否是半选 */
+    isIndeterminate: Boolean,
+    /** 全选按钮文字 */
+    checkAllText: String,
+    /** 选中后的文字 */
+    selectedText: String,
+    /** 文件右键菜单是否打开 */
+    ctxMenuDropdownVisible: Boolean,
+    /** 当前打开的右键菜单对应的文件数据 */
+    contextMenuFileItem: Object
+  },
+  emits: {
+    checkAllChange: () => true,
+    itemClick: (_item) => true,
+    itemCheckChange: (_item) => true,
+    itemContextOpen: (_option) => true
+  },
+  setup(props, { emit }) {
+    const headerText = vue.computed(() => {
+      if (!props.selections || !props.selections.length) {
+        return props.checkAllText;
+      }
+      if (!props.selectedText) {
+        return "";
+      }
+      return props.selectedText.replace(
+        /\{\s*total\s*\}/g,
+        String(props.selections.length)
+      );
+    });
+    const handleCheckAllChange = () => {
+      emit("checkAllChange");
+    };
+    const handleItemClick = (item) => {
+      emit("itemClick", item);
+    };
+    const handleItemCheckChange = (item) => {
+      emit("itemCheckChange", item);
+    };
+    const handleItemContextOpen = (option) => {
+      emit("itemContextOpen", option);
+    };
+    return {
+      headerText,
+      handleCheckAllChange,
+      handleItemClick,
+      handleItemCheckChange,
+      handleItemContextOpen
+    };
+  }
+});
+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,
+  class: "ele-file-list-header"
+};
+const _hoisted_2 = { class: "ele-file-list-body" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_FileGridItem = vue.resolveComponent("FileGridItem");
+  const _component_ReceiverView = vue.resolveComponent("ReceiverView");
+  return vue.openBlock(), vue.createBlock(_component_ReceiverView, { class: "ele-file-list" }, {
+    default: vue.withCtx(() => [
+      _ctx.selectionType === "checkbox" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        vue.createElementVNode("div", {
+          class: "ele-file-list-selection",
+          onClick: _cache[0] || (_cache[0] = vue.withModifiers((...args) => _ctx.handleCheckAllChange && _ctx.handleCheckAllChange(...args), ["stop"]))
+        }, [
+          vue.createElementVNode("i", {
+            class: vue.normalizeClass([
+              "ele-file-list-checkbox",
+              { "is-checked": _ctx.isCheckAll },
+              { "is-indeterminate": _ctx.isIndeterminate }
+            ])
+          }, null, 2),
+          vue.createElementVNode("div", null, vue.toDisplayString(_ctx.headerText), 1)
+        ])
+      ])) : vue.createCommentVNode("", true),
+      vue.createElementVNode("div", _hoisted_2, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.data, (item) => {
+          return vue.openBlock(), vue.createBlock(_component_FileGridItem, {
+            key: item.key,
+            item,
+            selectionType: _ctx.selectionType,
+            selections: _ctx.selections,
+            current: _ctx.current,
+            icons: _ctx.icons,
+            ctxMenuDropdownVisible: _ctx.ctxMenuDropdownVisible && _ctx.contextMenuFileItem === item,
+            onClick: _ctx.handleItemClick,
+            onCheckChange: _ctx.handleItemCheckChange,
+            onContextOpen: _ctx.handleItemContextOpen
+          }, vue.createSlots({ _: 2 }, [
+            vue.renderList(Object.keys(_ctx.$slots), (name) => {
+              return {
+                name,
+                fn: vue.withCtx((slotProps) => [
+                  vue.renderSlot(_ctx.$slots, name, vue.mergeProps({ ref_for: true }, slotProps || {}))
+                ])
+              };
+            })
+          ]), 1032, ["item", "selectionType", "selections", "current", "icons", "ctxMenuDropdownVisible", "onClick", "onCheckChange", "onContextOpen"]);
+        }), 128))
+      ])
+    ]),
+    _: 3
+  });
+}
+const fileGrid = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = fileGrid;

package/lib/ele-file-list/components/file-grid.d.ts

@@ -0,0 +1,181 @@
+import { PropType } from 'vue';
+import { IconItem, FileItem, SelectionType, ContextOpenOption } from '../types';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 文件数据 */
+    data: PropType<FileItem[]>;
+    /** 后缀对应的图标 */
+    icons: PropType<IconItem[]>;
+    /** 选择框类型 */
+    selectionType: PropType<SelectionType>;
+    /** 已选中的数据 */
+    selections: PropType<FileItem[]>;
+    /** 单选选中数据 */
+    current: PropType<FileItem>;
+    /** 是否是全选 */
+    isCheckAll: BooleanConstructor;
+    /** 是否是半选 */
+    isIndeterminate: BooleanConstructor;
+    /** 全选按钮文字 */
+    checkAllText: StringConstructor;
+    /** 选中后的文字 */
+    selectedText: StringConstructor;
+    /** 文件右键菜单是否打开 */
+    ctxMenuDropdownVisible: BooleanConstructor;
+    /** 当前打开的右键菜单对应的文件数据 */
+    contextMenuFileItem: PropType<FileItem | null>;
+}>, {
+    headerText: import('vue').ComputedRef<string | undefined>;
+    handleCheckAllChange: () => void;
+    handleItemClick: (item: FileItem) => void;
+    handleItemCheckChange: (item: FileItem) => void;
+    handleItemContextOpen: (option: ContextOpenOption) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    checkAllChange: () => true;
+    itemClick: (_item: FileItem) => true;
+    itemCheckChange: (_item: FileItem) => true;
+    itemContextOpen: (_option: ContextOpenOption) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 文件数据 */
+    data: PropType<FileItem[]>;
+    /** 后缀对应的图标 */
+    icons: PropType<IconItem[]>;
+    /** 选择框类型 */
+    selectionType: PropType<SelectionType>;
+    /** 已选中的数据 */
+    selections: PropType<FileItem[]>;
+    /** 单选选中数据 */
+    current: PropType<FileItem>;
+    /** 是否是全选 */
+    isCheckAll: BooleanConstructor;
+    /** 是否是半选 */
+    isIndeterminate: BooleanConstructor;
+    /** 全选按钮文字 */
+    checkAllText: StringConstructor;
+    /** 选中后的文字 */
+    selectedText: StringConstructor;
+    /** 文件右键菜单是否打开 */
+    ctxMenuDropdownVisible: BooleanConstructor;
+    /** 当前打开的右键菜单对应的文件数据 */
+    contextMenuFileItem: PropType<FileItem | null>;
+}>> & Readonly<{
+    onCheckAllChange?: (() => any) | undefined;
+    onItemClick?: ((_item: FileItem) => any) | undefined;
+    onItemCheckChange?: ((_item: FileItem) => any) | undefined;
+    onItemContextOpen?: ((_option: ContextOpenOption) => any) | undefined;
+}>, {
+    ctxMenuDropdownVisible: boolean;
+    isCheckAll: boolean;
+    isIndeterminate: 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: PropType<string | string[]>;
+            font: PropType<import('../../ele-watermark/types').WatermarkFont>;
+            gap: PropType<import('../../ele-watermark/types').WatermarkGap>;
+            offset: PropType<import('../../ele-watermark/types').WatermarkOffset>;
+            lineGap: {
+                type: NumberConstructor;
+                default: number;
+            };
+            customStyle: 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: PropType<string | string[]>;
+            font: PropType<import('../../ele-watermark/types').WatermarkFont>;
+            gap: PropType<import('../../ele-watermark/types').WatermarkGap>;
+            offset: PropType<import('../../ele-watermark/types').WatermarkOffset>;
+            lineGap: {
+                type: NumberConstructor;
+                default: number;
+            };
+            customStyle: 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>;
+    FileGridItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        item: {
+            type: PropType<FileItem>;
+            required: true;
+        };
+        selectionType: PropType<SelectionType>;
+        selections: PropType<FileItem[]>;
+        current: PropType<FileItem>;
+        icons: PropType<IconItem[]>;
+        ctxMenuDropdownVisible: BooleanConstructor;
+    }>, {
+        dropdownTriggerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        selectable: import('vue').ComputedRef<boolean>;
+        selected: import('vue').ComputedRef<boolean>;
+        icon: import('vue').ComputedRef<string | undefined>;
+        handleClick: () => void;
+        handleCheckChange: () => void;
+        handleContextmenu: (e: MouseEvent) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: (_item: FileItem) => true;
+        checkChange: (_item: FileItem) => true;
+        contextOpen: (_option: ContextOpenOption) => true;
+    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        item: {
+            type: PropType<FileItem>;
+            required: true;
+        };
+        selectionType: PropType<SelectionType>;
+        selections: PropType<FileItem[]>;
+        current: PropType<FileItem>;
+        icons: PropType<IconItem[]>;
+        ctxMenuDropdownVisible: BooleanConstructor;
+    }>> & Readonly<{
+        onClick?: ((_item: FileItem) => any) | undefined;
+        onCheckChange?: ((_item: FileItem) => any) | undefined;
+        onContextOpen?: ((_option: ContextOpenOption) => any) | undefined;
+    }>, {
+        ctxMenuDropdownVisible: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/ele-file-list/components/file-sort.cjs

@@ -0,0 +1,34 @@
+"use strict";
+const vue = require("vue");
+const _sfc_main = vue.defineComponent({
+  name: "FileSort",
+  props: {
+    /** 当前排序字段 */
+    sort: String,
+    /** 当前排序方式 */
+    order: String,
+    /** 排序字段名称 */
+    name: {
+      type: String,
+      required: true
+    }
+  }
+});
+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) {
+  return vue.openBlock(), vue.createElementBlock("i", {
+    class: vue.normalizeClass([
+      "ele-file-list-item-sort",
+      { "is-asc": _ctx.name === _ctx.sort && "asc" === _ctx.order },
+      { "is-desc": _ctx.name === _ctx.sort && "desc" === _ctx.order }
+    ])
+  }, null, 2);
+}
+const fileSort = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = fileSort;