ele-admin-plus 1.5.1-beta.4 → 1.6.0-beta.2

package/es/utils/core.d.ts

@@ -1,35 +1,41 @@
 /**
  * toTree 方法参数
  */
-export interface ToTreeOption<T> {
+export interface ToTreeOption<T, K> {
     /** 数据 */
     data?: T[] | null;
     /** id 字段名称 */
-    idField?: string | null;
+    idField?: keyof T | null;
     /** parentId 字段名称 */
-    parentIdField?: string | null;
+    parentIdField?: keyof T | null;
     /** 生成的 children 字段名称 */
-    childrenField?: string | null;
+    childrenField?: keyof K | null;
     /** 最顶级的 parentId 值 */
     parentId?: number | string | (number | string)[] | null;
     /** 是否添加包含所有父级 id 的字段 */
     addParentIds?: boolean | null;
     /** 包含所有父级 id 字段的名称 */
-    parentIdsField?: string | null;
-    /** 所有父级的 id */
+    parentIdsField?: keyof K | null;
+    /** 所有父级的 id (内部处理时使用) */
     parentIds?: (number | string)[] | null;
     /** 是否添加包含所有父级的字段 */
     addParents?: boolean | null;
     /** 包含所有父级字段的名称 */
-    parentsField?: string | null;
-    /** 所有父级 */
+    parentsField?: keyof K | null;
+    /** 所有父级(内部处理时使用) */
     parents?: T[] | null;
+    /** 格式器 */
+    formatter?: (item: T, index: number, parent?: T | K) => K | void | undefined;
+    /** 当前的父级(内部处理时使用) */
+    parent?: T | K | undefined;
+    /** 后置格式器 */
+    afterFormatter?: (item: K, index: number, parent?: T | K) => K | void | undefined;
 }
 /**
  * parentId 形式数据转 children 形式
  * @param option ToTreeOption
  */
-export declare function toTree<T>(option: ToTreeOption<T>): T[];
+export declare function toTree<T, K = T>(option: ToTreeOption<T, K>): K[];
 /**
  * 遍历 children 形式数据
  * @param data 数据
@@ -37,7 +43,7 @@ export declare function toTree<T>(option: ToTreeOption<T>): T[];
  * @param childrenField children 字段名
  * @param parent 当前的父级
  */
-export declare function eachTree<T>(data?: T[], callback?: (item: T, index: number, parent?: T) => void | boolean, childrenField?: string, parent?: T): false | undefined;
+export declare function eachTree<T>(data?: T[], callback?: (item: T, index: number, parent?: T) => void | boolean, childrenField?: keyof T, parent?: T): false | undefined;
 /**
  * 处理 children 形式数据
  * @param data 数据
@@ -45,16 +51,16 @@ export declare function eachTree<T>(data?: T[], callback?: (item: T, index: numb
  * @param childrenField children 字段名
  * @param resultChildrenField 返回后的 children 字段名
  * @param afterFormatter 后置格式器
- * @param parent 当前的父级
+ * @param parent 当前的父级(内部处理时使用)
  */
-export declare function mapTree<T, K>(data: T[] | undefined | null, formatter: (item: T, index?: number, parent?: T | K) => K | void | undefined | 'flatChildren', childrenField?: string, resultChildrenField?: string, afterFormatter?: (item: K) => K | void | undefined, parent?: T | K): K[];
+export declare function mapTree<T, K = T>(data: T[] | undefined | null, formatter: (item: T, index?: number, parent?: T | K) => K | void | undefined | 'flatChildren', childrenField?: keyof T, resultChildrenField?: keyof K, afterFormatter?: (item: K, index: number, parent?: T | K) => K | void | undefined, parent?: K): K[];
 /**
  * 查找 children 形式数据
  * @param data 数据
  * @param predicate 查找条件
  * @param childrenField children 字段名
  */
-export declare function findTree<T>(data: T[] | undefined, predicate: (value: T, index: number) => unknown, childrenField?: string): T | undefined;
+export declare function findTree<T>(data: T[] | undefined, predicate: (item: T, index: number) => unknown, childrenField?: keyof T): T | undefined;
 /**
  * 检查是否全屏
  */
@@ -118,6 +124,13 @@ export interface FormatNumberOption {
  * @param option 参数
  */
 export declare function formatNumber(num?: number | string | null, option?: FormatNumberOption): string;
+/**
+ * 格式化文件大小
+ * @param size 文件大小
+ * @param decimal 保留小数位数
+ * @param units 大小单位
+ */
+export declare function formatFileSize(size: number, decimal?: number, units?: string[]): [string, number, string];
 /**
  * 赋值不改变原字段
  * @param target 目标对象

package/es/utils/core.js

@@ -12,58 +12,68 @@ function toTree(option) {
   const addParents = option.addParents;
   const parentsField = option.parentsField || "parents";
   const parents = option.parents ?? [];
-  if (data == null) {
+  const formatter = option.formatter;
+  const parent = option.parent;
+  const afterFormatter = option.afterFormatter;
+  if (data == null || !Array.isArray(data)) {
     return [];
   }
   if (parentIdIsNull) {
     data.forEach((d) => {
-      if (!data.some((t) => d[parentIdField] == t[idField]) && !parentId.includes(d[parentIdField])) {
+      if (d && typeof d === "object" && !data.some(
+        (t) => t && typeof t === "object" && d[parentIdField] == t[idField]
+      ) && !parentId.includes(d[parentIdField])) {
         parentId.push(d[parentIdField]);
       }
     });
   }
   const result = [];
-  data.forEach((d) => {
-    if (d[idField] == d[parentIdField]) {
-      const error = {
-        [idField]: d[idField],
-        [parentIdField]: d[parentIdField],
-        data: d
-      };
-      console.error("data error:", error);
-      throw new Error("data error");
+  data.forEach((d, i) => {
+    if (!d || typeof d !== "object") {
+      return;
     }
-    if (parentIdIsArray ? parentId.includes(d[parentIdField]) : d[parentIdField] == parentId) {
-      const t = { ...d };
-      const children = toTree({
-        data,
-        idField,
-        parentIdField,
-        childrenField,
-        parentId: d[idField],
-        addParentIds,
-        parentIdsField,
-        parentIds: addParentIds ? [...parentIds, d[idField]] : [],
-        addParents,
-        parentsField,
-        parents: addParents ? [...parents, t] : []
-      });
-      if (children.length > 0) {
-        t[childrenField] = children;
-      }
-      if (addParentIds) {
-        t[parentIdsField] = parentIds;
-      }
-      if (addParents) {
-        t[parentsField] = parents;
-      }
-      result.push(t);
+    const dParentId = d[idField] == d[parentIdField] ? void 0 : d[parentIdField];
+    if (!(parentIdIsArray ? parentId.some((id) => id == dParentId) : dParentId == parentId)) {
+      return;
+    }
+    const t = formatter ? formatter(d, i, parent) : { ...d };
+    if (!t || typeof t !== "object") {
+      return;
+    }
+    const children = toTree({
+      data,
+      idField,
+      parentIdField,
+      childrenField,
+      parentId: d[idField],
+      addParentIds,
+      parentIdsField,
+      parentIds: addParentIds ? [...parentIds, d[idField]] : [],
+      addParents,
+      parentsField,
+      parents: addParents ? [...parents, t] : [],
+      formatter,
+      parent: t,
+      afterFormatter
+    });
+    if (children.length > 0) {
+      t[childrenField] = children;
+    }
+    if (addParentIds) {
+      t[parentIdsField] = parentIds;
+    }
+    if (addParents) {
+      t[parentsField] = parents;
+    }
+    const r = afterFormatter ? afterFormatter(t, i, parent) : t;
+    if (r) {
+      result.push(r);
     }
   });
   return result;
 }
-function eachTree(data, callback, childrenField = "children", parent) {
-  if (!data) {
+function eachTree(data, callback, childrenField, parent) {
+  if (!data || !Array.isArray(data)) {
     return;
   }
   for (let i = 0; i < data.length; i++) {
@@ -71,39 +81,38 @@ function eachTree(data, callback, childrenField = "children", parent) {
     if (flag === false) {
       return false;
     }
-    if (data[i][childrenField]?.length) {
-      if (eachTree(data[i][childrenField], callback, childrenField, data[i]) === false) {
-        return false;
-      }
+    const cField = childrenField || "children";
+    if (data[i] && typeof data[i] === "object" && eachTree(data[i][cField], callback, cField, data[i]) === false) {
+      return false;
     }
   }
 }
-function formatTreeItem(item, index, parent, formatter, childrenField = "children", resultChildrenField = "children", afterFormatter) {
+function formatTreeItem(item, index, parent, formatter, childrenField, resultChildrenField, afterFormatter) {
   const result = [];
   const itemResult = formatter(item, index, parent);
   if (itemResult === "flatChildren") {
-    const children = item[childrenField];
-    if (children) {
-      children.forEach((c, j) => {
+    const children = item && typeof item === "object" ? item[childrenField] : void 0;
+    if (children && Array.isArray(children)) {
+      children.forEach((c, cIndex) => {
         const childItems = formatTreeItem(
           c,
-          j,
+          cIndex,
           item,
           formatter,
           childrenField,
           resultChildrenField,
           afterFormatter
         );
-        childItems.forEach((childItem) => {
-          const afterItem = afterFormatter ? afterFormatter(childItem) : childItem;
+        childItems.forEach((childItem, childIndex) => {
+          const afterItem = afterFormatter ? afterFormatter(childItem, childIndex, item) : childItem;
           if (afterItem) {
             result.push(afterItem);
           }
         });
       });
     }
-  } else if (itemResult) {
-    if (item[childrenField] != null) {
+  } else if (itemResult && typeof itemResult === "object") {
+    if (item && typeof item === "object" && item[childrenField] != null) {
       itemResult[resultChildrenField] = mapTree(
         item[childrenField],
         formatter,
@@ -113,24 +122,24 @@ function formatTreeItem(item, index, parent, formatter, childrenField = "childre
         itemResult
       );
     }
-    const afterItem = afterFormatter ? afterFormatter(itemResult) : itemResult;
+    const afterItem = afterFormatter ? afterFormatter(itemResult, index, parent) : itemResult;
     if (afterItem) {
       result.push(afterItem);
     }
   }
   return result;
 }
-function mapTree(data, formatter, childrenField = "children", resultChildrenField = "children", afterFormatter, parent) {
+function mapTree(data, formatter, childrenField, resultChildrenField, afterFormatter, parent) {
   const result = [];
-  if (data) {
+  if (data && Array.isArray(data)) {
     data.forEach((d, i) => {
       const items = formatTreeItem(
         d,
         i,
         parent,
         formatter,
-        childrenField,
-        resultChildrenField,
+        childrenField || "children",
+        resultChildrenField || "children",
         afterFormatter
       );
       items.forEach((item) => {
@@ -252,6 +261,20 @@ function formatNumber(num, option) {
   }
   return result;
 }
+function formatFileSize(size, decimal = 2, units = ["B", "KB", "MB", "GB", "TB", "PB"]) {
+  if (!size) {
+    return [`0${units[0]}`, 0, units[0]];
+  }
+  const k = 1024;
+  const i = Math.min(
+    Math.floor(Math.log(size) / Math.log(k)),
+    units.length - 1
+  );
+  const convertedSize = size / Math.pow(k, i);
+  const fileUnit = units[i];
+  const fileSize = convertedSize.toFixed(decimal);
+  return [`${fileSize}${fileUnit}`, convertedSize, fileUnit];
+}
 function assignObject(target, source, excludes) {
   Object.keys(target).forEach((key) => {
     if (!excludes?.includes?.(key)) {
@@ -305,6 +328,7 @@ export {
   eachTree,
   exitFullscreen,
   findTree,
+  formatFileSize,
   formatNumber,
   gcj02ToBd09,
   isExternalLink,

package/es/utils/helper.d.ts

@@ -0,0 +1,7 @@
+import { CreateItemHelper } from '../ele-buttons/types';
+
+/**
+ * 按钮数据类型推导辅助函数
+ * @param item 按钮数据
+ */
+export declare const createButtonItem: CreateItemHelper;

package/es/utils/helper.js

@@ -0,0 +1,4 @@
+const createButtonItem = (item) => item;
+export {
+  createButtonItem
+};

package/es/utils/hook.d.ts

@@ -5,8 +5,15 @@ import { EmitMethods } from '../ele-app/types';
  * useTimer 返回结果
  */
 export type UseTimerResult = [
+    /**
+     * 开始定时执行方法
+     * @param callback 重设执行方法
+     * @param timeout 重设等待时间
+     */
     (callback?: () => void, timeout?: number) => void,
+    /** 停止定时器 */
     () => void,
+    /** 方法是否等待执行状态 */
     Ref<boolean>
 ];
 /**
@@ -29,6 +36,10 @@ export declare function useMediaQuery(query: string, onChange?: () => void): Use
  * 移动端小屏幕媒体查询
  */
 export declare const mobileMediaQuery = "(max-width: 767.99px)";
+/**
+ * 移动端触摸设备媒体查询
+ */
+export declare const mobileDeviceMediaQuery = "(pointer: coarse)";
 /**
  * useMobile 返回结果
  */

package/es/utils/hook.js

@@ -53,6 +53,7 @@ function useMediaQuery(query, onChange) {
   return [mediaQuery, startWatch, stopWatch];
 }
 const mobileMediaQuery = "(max-width: 767.99px)";
+const mobileDeviceMediaQuery = "(pointer: coarse)";
 function useMobile(onChange) {
   const mobile = ref(false);
   const [media, startMedia, stopMedia] = useMediaQuery(mobileMediaQuery, () => {
@@ -68,7 +69,7 @@ function useMobile(onChange) {
 function useMobileDevice(onChange) {
   const mobileDevice = ref(false);
   const [media, startMedia, stopMedia] = useMediaQuery(
-    "(pointer: coarse)",
+    mobileDeviceMediaQuery,
     () => {
       const isMobileDevice = media.matches;
       if (mobileDevice.value !== isMobileDevice) {
@@ -134,7 +135,7 @@ function useCollapseAnim() {
     handleAfterLeave
   };
 }
-const modalItemContextKey = Symbol(
+const modalItemContextKey = /* @__PURE__ */ Symbol(
   "modalItemContextKey"
 );
 function useMousewheel(cb) {
@@ -437,6 +438,7 @@ function useFormItemRest() {
   provide(formItemContextKey, null);
 }
 export {
+  mobileDeviceMediaQuery,
   mobileMediaQuery,
   modalItemContextKey,
   useCollapseAnim,

package/es/utils/lib-export-umd.d.ts

@@ -0,0 +1,2 @@
+export declare function debugWarn(): void;
+export declare const elTableProps: any;

package/es/utils/lib-export-umd.js

@@ -0,0 +1,7 @@
+function debugWarn() {
+}
+const elTableProps = ElementPlus.ElTable.props;
+export {
+  debugWarn,
+  elTableProps
+};

package/es/utils/lib-export.d.ts

@@ -0,0 +1,230 @@
+import { PropType } from 'vue';
+import { TableProps } from 'element-plus';
+import { debugWarn } from 'element-plus/es/utils/error';
+
+/** 解决 table/defaults.mjs 导出了 default 而 table/defaults.d.ts 没有导出 default 导致类型无法识别的问题 */
+export declare const tablePropsType: {
+    /**
+     * @description table data
+     */
+    data: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    /**
+     * @description size of Table
+     */
+    size: {
+        type: PropType<TableProps<Record<string, any>>["size"]>;
+    };
+    width: (StringConstructor | NumberConstructor)[];
+    /**
+     * @description table's height. By default it has an `auto` height. If its value is a number, the height is measured in pixels; if its value is a string, the value will be assigned to element's style.height, the height is affected by external styles
+     */
+    height: (StringConstructor | NumberConstructor)[];
+    /**
+     * @description table's max-height. The legal value is a number or the height in px
+     */
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    /**
+     * @description whether width of column automatically fits its container
+     */
+    fit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description whether Table is striped
+     */
+    stripe: BooleanConstructor;
+    /**
+     * @description whether Table has vertical border
+     */
+    border: BooleanConstructor;
+    /**
+     * @description key of row data, used for optimizing rendering. Required if `reserve-selection` is on or display tree data. When its type is String, multi-level access is supported, e.g. `user.info.id`, but `user.info[0].id` is not supported, in which case `Function` should be used
+     */
+    rowKey: PropType<TableProps<any>["rowKey"]>;
+    /**
+     * @description whether Table header is visible
+     */
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description whether to display a summary row
+     */
+    showSummary: BooleanConstructor;
+    /**
+     * @description displayed text for the first column of summary row
+     */
+    sumText: StringConstructor;
+    /**
+     * @description custom summary method
+     */
+    summaryMethod: PropType<TableProps<any>["summaryMethod"]>;
+    /**
+     * @description function that returns custom class names for a row, or a string assigning class names for every row
+     */
+    rowClassName: PropType<TableProps<any>["rowClassName"]>;
+    /**
+     * @description function that returns custom style for a row, or an object assigning custom style for every row
+     */
+    rowStyle: PropType<TableProps<any>["rowStyle"]>;
+    /**
+     * @description function that returns custom class names for a cell, or a string assigning class names for every cell
+     */
+    cellClassName: PropType<TableProps<any>["cellClassName"]>;
+    /**
+     * @description function that returns custom style for a cell, or an object assigning custom style for every cell
+     */
+    cellStyle: PropType<TableProps<any>["cellStyle"]>;
+    /**
+     * @description function that returns custom class names for a row in table header, or a string assigning class names for every row in table header
+     */
+    headerRowClassName: PropType<TableProps<any>["headerRowClassName"]>;
+    /**
+     * @description function that returns custom style for a row in table header, or an object assigning custom style for every row in table header
+     */
+    headerRowStyle: PropType<TableProps<any>["headerRowStyle"]>;
+    /**
+     * @description function that returns custom class names for a cell in table header, or a string assigning class names for every cell in table header
+     */
+    headerCellClassName: PropType<TableProps<any>["headerCellClassName"]>;
+    /**
+     * @description function that returns custom style for a cell in table header, or an object assigning custom style for every cell in table header
+     */
+    headerCellStyle: PropType<TableProps<any>["headerCellStyle"]>;
+    /**
+     * @description whether current row is highlighted
+     */
+    highlightCurrentRow: BooleanConstructor;
+    /**
+     * @description key of current row, a set only prop
+     */
+    currentRowKey: (StringConstructor | NumberConstructor)[];
+    /**
+     * @description displayed text when data is empty. You can customize this area with `#empty`
+     */
+    emptyText: StringConstructor;
+    /**
+     * @description set expanded rows by this prop, prop's value is the keys of expand rows, you should set row-key before using this prop
+     */
+    expandRowKeys: PropType<TableProps<any>["expandRowKeys"]>;
+    /**
+     * @description whether expand all rows by default, works when the table has a column type="expand" or contains tree structure data
+     */
+    defaultExpandAll: BooleanConstructor;
+    /**
+     * @description enable expandable rows, works when the table has a column type="expand"
+     */
+    rowExpandable: {
+        type: PropType<TableProps<any>["rowExpandable"]>;
+    };
+    /**
+     * @description set the default sort column and order. property `prop` is used to set default sort column, property `order` is used to set default sort order
+     */
+    defaultSort: PropType<TableProps<any>["defaultSort"]>;
+    /**
+     * @description the `effect` of the overflow tooltip
+     */
+    tooltipEffect: StringConstructor;
+    /**
+     * @description the options for the overflow tooltip, [see the following tooltip component](tooltip.html#attributes)
+     */
+    tooltipOptions: PropType<TableProps<any>["tooltipOptions"]>;
+    /**
+     * @description method that returns rowspan and colspan
+     */
+    spanMethod: PropType<TableProps<any>["spanMethod"]>;
+    /**
+     * @description controls the behavior of master checkbox in multi-select tables when only some rows are selected (but not all). If true, all rows will be selected, else deselected
+     */
+    selectOnIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description horizontal indentation of tree data
+     */
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * @description configuration for rendering nested data
+     */
+    treeProps: {
+        type: PropType<TableProps<any>["treeProps"]>;
+        default: () => {
+            hasChildren: string;
+            children: string;
+            checkStrictly: boolean;
+        };
+    };
+    /**
+     * @description whether to lazy loading data
+     */
+    lazy: BooleanConstructor;
+    /**
+     * @description method for loading child row data, only works when `lazy` is true
+     */
+    load: PropType<TableProps<any>["load"]>;
+    style: {
+        type: PropType<TableProps<any>["style"]>;
+        default: () => {};
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * @description sets the algorithm used to lay out table cells, rows, and columns
+     */
+    tableLayout: {
+        type: PropType<TableProps<Record<string, any>>["tableLayout"]>;
+        default: string;
+    };
+    /**
+     * @description always show scrollbar
+     */
+    scrollbarAlwaysOn: BooleanConstructor;
+    /**
+     * @description ensure main axis minimum-size doesn't follow the content
+     */
+    flexible: BooleanConstructor;
+    /**
+     * @description whether to hide extra content and show them in a tooltip when hovering on the cell.It will affect all the table columns
+     */
+    showOverflowTooltip: {
+        type: PropType<TableProps<any>["showOverflowTooltip"]>;
+        default: undefined;
+    };
+    /**
+     * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+     */
+    tooltipFormatter: PropType<TableProps<any>["tooltipFormatter"]>;
+    appendFilterPanelTo: StringConstructor;
+    scrollbarTabindex: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    /**
+     * @description whether to allow drag the last column
+     */
+    allowDragLastColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description whether to preserve expanded row content in DOM when collapsed
+     */
+    preserveExpandedContent: BooleanConstructor;
+    /**
+     * @description whether to use native scrollbars
+     */
+    nativeScrollbar: BooleanConstructor;
+};
+export declare const elTableProps: typeof tablePropsType;
+export { debugWarn };