ele-admin-plus 1.1.4 → 1.1.5-beta.1

package/lib/ele-virtual-table/util.js

@@ -0,0 +1,562 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const core = require("../utils/core");
+const util = require("../ele-data-table/util");
+function getRowHeight(size, rowHeight) {
+  if (rowHeight != null && rowHeight > 0) {
+    return rowHeight;
+  }
+  if (size === "small") {
+    return 34;
+  }
+  if (size === "large") {
+    return 50;
+  }
+  return 42;
+}
+function getColKey(column) {
+  if (!column) {
+    return "";
+  }
+  return column.columnKey ?? column.property ?? column.prop ?? "";
+}
+function getNumberSize(size, defaultValue) {
+  if (typeof size === "number") {
+    if (size < 0) {
+      return defaultValue;
+    }
+    return size;
+  }
+  if (size == null || size === "" || size === "auto" || size.endsWith("%")) {
+    return defaultValue;
+  }
+  const num = Number.parseInt(size);
+  return isNaN(num) ? defaultValue : num;
+}
+function getTableHeight(height, maxHeight, minHeight, wrapHeight) {
+  const max = getNumberSize(maxHeight);
+  const h = getNumberSize(height);
+  if (h != null) {
+    return max == null || h <= max ? h : max;
+  }
+  return Math.max(wrapHeight, minHeight);
+}
+function computeFixedCols(cols) {
+  let lastFixedLeftIndex;
+  let firstFixedRightIndex;
+  cols.forEach((col, i) => {
+    const c = col.originalCol;
+    if (c) {
+      if (c.fixed === "left" || c.fixed === true) {
+        lastFixedLeftIndex = i;
+      } else if (firstFixedRightIndex == null && c.fixed === "right") {
+        firstFixedRightIndex = i;
+      }
+    }
+  });
+  if (lastFixedLeftIndex != null) {
+    cols[lastFixedLeftIndex].isFixedLeftLast = true;
+  }
+  if (firstFixedRightIndex != null) {
+    cols[firstFixedRightIndex].isFixedRightFirst = true;
+  }
+}
+function generateRowCols(columns, cols, rows, level, parentRowCol) {
+  if (rows[level] == null) {
+    rows[level] = [];
+  }
+  columns.forEach((col) => {
+    const colKey = getColKey(col);
+    const originalCol = core.omit(col, ["children"]);
+    if (parentRowCol != null && parentRowCol.originalCol != null) {
+      originalCol.fixed = parentRowCol.originalCol.fixed;
+    }
+    const rowCol = { key: colKey, originalCol };
+    if (col.children && col.children.length) {
+      rowCol.rowspan = 1;
+      rowCol.colspan = col.children.length;
+      generateRowCols(col.children, cols, rows, level + 1, rowCol);
+      if (parentRowCol && parentRowCol.colspan != null) {
+        parentRowCol.colspan += rowCol.colspan - 1;
+      }
+    } else {
+      rowCol.colspan = 1;
+      const bodyCol = {
+        width: getNumberSize(col.width),
+        minWidth: getNumberSize(col.minWidth, 80),
+        key: colKey,
+        dataKey: col.property ?? col.prop,
+        originalCol
+      };
+      cols.push(bodyCol);
+    }
+    rows[level].push(rowCol);
+  });
+}
+function analyseColumns(columns) {
+  const cols = [];
+  const rows = [];
+  if (!columns || !columns.length) {
+    return { cols, rows };
+  }
+  generateRowCols(columns, cols, rows, 0);
+  computeFixedCols(cols);
+  rows.forEach((row, i) => {
+    row.forEach((col) => {
+      if (col != null && col.rowspan == null) {
+        col.rowspan = rows.length - i;
+      }
+    });
+    computeFixedCols(row);
+  });
+  for (let i = 0; i < rows.length; i++) {
+    for (let j = 0; j < rows[i].length; j++) {
+      const row = rows[i][j];
+      if (row.colspan != null && row.colspan > 1) {
+        for (let n = 1; n < row.colspan; n++) {
+          rows[i].splice(j + n, 0, { colspan: 0, rowspan: 1 });
+        }
+      }
+      if (row.rowspan != null && row.rowspan > 1) {
+        for (let n = 1; n < row.rowspan; n++) {
+          rows[i + n].splice(j, 0, { colspan: 1, rowspan: 0 });
+        }
+      }
+    }
+  }
+  return { cols, rows };
+}
+function getColWidth(col, tableWidth, colsWidth, colsMinWidth) {
+  if (col.width != null) {
+    return col.width;
+  }
+  if (col.minWidth == null) {
+    return 0;
+  }
+  const surplusWidth = tableWidth - colsWidth;
+  if (surplusWidth <= colsMinWidth) {
+    return col.minWidth;
+  }
+  return Math.floor(col.minWidth / colsMinWidth * surplusWidth);
+}
+function computeFixedPositions(cols, colSizes) {
+  let left = 0;
+  cols.forEach((col, i) => {
+    const c = col.originalCol;
+    if (c && (c.fixed === "left" || c.fixed === true)) {
+      colSizes[i].fixedLeft = left + "px";
+      if (colSizes[i].width) {
+        left += colSizes[i].width;
+      }
+    }
+  });
+  let right = 0;
+  for (let i = cols.length - 1; i >= 0; i--) {
+    const c = cols[i].originalCol;
+    if (c && c.fixed === "right") {
+      colSizes[i].fixedRight = right + "px";
+      if (colSizes[i].width) {
+        right += colSizes[i].width;
+      }
+    }
+  }
+}
+function computeColSizes(cols, rows, wrapWidth) {
+  let isFixed = true;
+  let colsSumWidth = 0;
+  let colsSumMinWidth = 0;
+  cols.forEach((col) => {
+    if (col.width == null) {
+      isFixed = false;
+      if (col.minWidth != null) {
+        colsSumMinWidth += col.minWidth;
+      }
+      return;
+    }
+    colsSumWidth += col.width;
+  });
+  const tableWidth = isFixed ? Math.min(wrapWidth, colsSumWidth) : wrapWidth;
+  const colSizes = [];
+  let sumWidth = 0;
+  cols.forEach((col, i) => {
+    const width = getColWidth(col, tableWidth, colsSumWidth, colsSumMinWidth);
+    sumWidth += width;
+    colSizes[i] = { width };
+    if (i === cols.length - 1 && tableWidth > sumWidth) {
+      colSizes[i].width = width + tableWidth - sumWidth;
+      sumWidth = tableWidth;
+    }
+  });
+  computeFixedPositions(cols, colSizes);
+  const rowSizes = [];
+  rows.forEach((row) => {
+    const sizes = [];
+    row.forEach((col, colIndex) => {
+      if (!cols[colIndex] || !col.colspan) {
+        sizes[colIndex] = { width: 0 };
+        return;
+      }
+      let width = colSizes[colIndex].width || 0;
+      if (col.colspan > 1) {
+        const end = colIndex + col.colspan;
+        for (let i = colIndex + 1; i < end; i++) {
+          if (colSizes[i] && colSizes[i].width) {
+            width += colSizes[i].width;
+          }
+        }
+      }
+      sizes[colIndex] = { width };
+    });
+    rowSizes.push(sizes);
+    computeFixedPositions(row, sizes);
+  });
+  return { width: tableWidth, colSizes, rowSizes, sumWidth };
+}
+function colSizesIsChanged(colSizes, newSizes) {
+  if (colSizes.length !== newSizes.length) {
+    return true;
+  }
+  for (let i = 0; i < colSizes.length; i++) {
+    if (colSizes[i].width !== newSizes[i].width) {
+      return true;
+    }
+  }
+  return false;
+}
+function getTableColumns(bodyCols, colSizes) {
+  const columns = bodyCols.map((col, i) => {
+    return {
+      title: col.originalCol ? col.originalCol.label : void 0,
+      width: colSizes[i].width,
+      key: col.key,
+      dataKey: col.dataKey
+    };
+  });
+  return columns.filter((col) => !!col.width);
+}
+function transformTableData(data, hasExpandCol, childrenName, rowKey, selectable) {
+  if (!data || !data.length) {
+    return [];
+  }
+  if (hasExpandCol) {
+    return data.map((d, i) => {
+      const key = util.getValue(d, rowKey);
+      const temp = {
+        _rowKey: "_expand_" + key,
+        _isExpandRow: true,
+        _expandParent: d,
+        _expandParantIndex: i
+      };
+      return {
+        ...d,
+        _rowKey: key,
+        _rowIndex: i,
+        _rowDisabled: !(selectable == null || selectable(d, index) === true),
+        children: [temp]
+      };
+    });
+  }
+  let index = -1;
+  return core.mapTree(
+    data,
+    (d) => {
+      index++;
+      return {
+        ...d,
+        _rowKey: util.getValue(d, rowKey),
+        _rowIndex: index,
+        _rowDisabled: !!(selectable && !selectable(d, index))
+      };
+    },
+    childrenName
+  );
+}
+function isAutoRowHeight(hasExpandCol, bodyCols, showOverflowTooltip) {
+  if (hasExpandCol) {
+    return true;
+  }
+  let isAllEllipsis = true;
+  for (let i = 0; i < bodyCols.length; i++) {
+    const col = bodyCols[i].originalCol;
+    if (col && col.type !== "selection" && col.type !== "expand") {
+      if (col.showOverflowTooltip == null) {
+        isAllEllipsis = false;
+      } else if (col.showOverflowTooltip === false) {
+        return true;
+      }
+    }
+  }
+  if (isAllEllipsis) {
+    return false;
+  }
+  return showOverflowTooltip == null || showOverflowTooltip === false;
+}
+function CellRender(props, ctx) {
+  var _a, _b;
+  if (typeof props.render === "function" && props.params != null) {
+    const node = props.render(...props.params);
+    if (node != null) {
+      return Array.isArray(node) ? node : [node];
+    }
+  }
+  return (_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a);
+}
+function getSortBy(current, col) {
+  const key = getColKey(col);
+  if (current == null || current.order == null || current.key !== key) {
+    return { key, order: elementPlus.TableV2SortOrder.ASC };
+  }
+  if (current.order === elementPlus.TableV2SortOrder.DESC) {
+    return;
+  }
+  return { key, order: elementPlus.TableV2SortOrder.DESC };
+}
+function getSortOrder(order) {
+  if (order === "ascending") {
+    return elementPlus.TableV2SortOrder.ASC;
+  }
+  if (order === "descending") {
+    return elementPlus.TableV2SortOrder.DESC;
+  }
+}
+function getOrderValue(sort) {
+  if (sort != null) {
+    if (sort === elementPlus.TableV2SortOrder.ASC) {
+      return "ascending";
+    }
+    if (sort === elementPlus.TableV2SortOrder.DESC) {
+      return "descending";
+    }
+  }
+}
+function getDefaultSort(defaultSort) {
+  if (!defaultSort) {
+    return;
+  }
+  const { prop, order } = defaultSort;
+  if (!prop || !order || !["ascending", "descending"].includes(order)) {
+    return;
+  }
+  return {
+    key: prop,
+    order: order === "ascending" ? elementPlus.TableV2SortOrder.ASC : elementPlus.TableV2SortOrder.DESC
+  };
+}
+function getDefaultFiltered(columns) {
+  const filtered = {};
+  core.eachTree(columns, (col) => {
+    const key = getColKey(col);
+    if (key && col.filteredValue != null && col.filteredValue.length) {
+      filtered[key] = col.filteredValue;
+    }
+  });
+  return filtered;
+}
+function getColFiltered(col, filtered) {
+  if (!col) {
+    return;
+  }
+  if (!filtered) {
+    return col.filteredValue;
+  }
+  const key = getColKey(col);
+  if (!key) {
+    return col.filteredValue;
+  }
+  return filtered[key] ?? col.filteredValue;
+}
+function getSelectableFunc(cols) {
+  for (let i = 0; i < cols.length; i++) {
+    const c = cols[i].originalCol;
+    if (c && c.type === "selection") {
+      return typeof c.selectable === "function" ? c.selectable : null;
+    }
+  }
+}
+function getTreeProps(treeProps) {
+  const { children, hasChildren } = treeProps || {};
+  return {
+    childrenName: children || "children",
+    hasChildrenName: hasChildren || "hasChildren"
+  };
+}
+function getSumValue(data, prop) {
+  if (!data || !prop) {
+    return "";
+  }
+  let sum = 0;
+  for (let i = 0; i < data.length; i++) {
+    const val = Number(util.getValue(data[i], prop));
+    if (Number.isNaN(val)) {
+      return "";
+    }
+    sum += val;
+  }
+  return String(sum);
+}
+function getColumnByKey(columns, key, dataKey) {
+  let column = void 0;
+  if (columns != null && key != null) {
+    core.eachTree(columns, (col) => {
+      if (dataKey != null) {
+        if (col.property === dataKey || col.prop === dataKey) {
+          column = col;
+          return false;
+        }
+      } else if (getColKey(col) === key) {
+        column = col;
+        return false;
+      }
+    });
+  }
+  return column;
+}
+function floorSize(size) {
+  const floor = Math.floor(size);
+  if (size - floor < 1e-3) {
+    return floor;
+  }
+  return size;
+}
+function cellIsOverflow(cell) {
+  const cellChild = cell.querySelector(".ele-table-cell");
+  if (!cellChild || !cellChild.childNodes.length) {
+    return false;
+  }
+  const range = document.createRange();
+  range.setStart(cellChild, 0);
+  range.setEnd(cellChild, cellChild.childNodes.length);
+  const {
+    width
+    /* , height */
+  } = range.getBoundingClientRect();
+  const rangeWidth = floorSize(width);
+  const style = core.getCurrentStyle(cellChild);
+  const left = Number.parseInt(style.paddingLeft) || 0;
+  const right = Number.parseInt(style.paddingRight) || 0;
+  const horizontalPadding = left + right;
+  return rangeWidth + horizontalPadding > cellChild.offsetWidth || //rangeHeight + verticalPadding > cellChild.offsetHeight ||
+  cellChild.scrollWidth > cellChild.offsetWidth;
+}
+function useAutoResize(getEl) {
+  const wrapWidth = vue.ref(0);
+  const wrapHeight = vue.ref(0);
+  const updateWrapSize = () => {
+    const el = getEl();
+    if (el) {
+      const width = Math.floor(el.clientWidth);
+      if (wrapWidth.value !== width) {
+        wrapWidth.value = width;
+      }
+      const height = Math.floor(el.clientHeight);
+      if (wrapWidth.value !== height) {
+        wrapHeight.value = height;
+      }
+    }
+  };
+  const observer = new ResizeObserver(
+    core.debounce(() => {
+      updateWrapSize();
+    }, 400)
+  );
+  const observe = () => {
+    unobserve();
+    const el = getEl();
+    if (el) {
+      observer.observe(el);
+    }
+  };
+  const unobserve = () => {
+    const el = getEl();
+    if (el) {
+      observer.unobserve(el);
+    }
+  };
+  vue.onMounted(() => {
+    updateWrapSize();
+    observe();
+  });
+  vue.onBeforeMount(() => {
+    observer.disconnect();
+  });
+  vue.onActivated(() => {
+    updateWrapSize();
+    observe();
+  });
+  vue.onDeactivated(() => {
+    unobserve();
+  });
+  return { wrapWidth, wrapHeight, updateWrapSize };
+}
+function useState() {
+  const state = {
+    current: null,
+    selected: /* @__PURE__ */ new Map(),
+    scrollTop: 0
+  };
+  const getCurrent = () => {
+    return state.current;
+  };
+  const setCurrent = (row) => {
+    state.current = row == null ? null : row;
+  };
+  const getSelected = () => {
+    return Array.from(state.selected.values());
+  };
+  const addSelected = (key, row) => {
+    state.selected.set(key, row);
+  };
+  const removeSelected = (key) => {
+    state.selected.delete(key);
+  };
+  const clearSelected = () => {
+    state.selected.clear();
+  };
+  const getScrollTop = () => {
+    return state.scrollTop;
+  };
+  const cacheScrollTop = (top) => {
+    state.scrollTop = top;
+  };
+  return {
+    getCurrent,
+    setCurrent,
+    getSelected,
+    addSelected,
+    removeSelected,
+    clearSelected,
+    getScrollTop,
+    cacheScrollTop
+  };
+}
+exports.CellRender = CellRender;
+exports.analyseColumns = analyseColumns;
+exports.cellIsOverflow = cellIsOverflow;
+exports.colSizesIsChanged = colSizesIsChanged;
+exports.computeColSizes = computeColSizes;
+exports.computeFixedCols = computeFixedCols;
+exports.computeFixedPositions = computeFixedPositions;
+exports.floorSize = floorSize;
+exports.generateRowCols = generateRowCols;
+exports.getColFiltered = getColFiltered;
+exports.getColKey = getColKey;
+exports.getColWidth = getColWidth;
+exports.getColumnByKey = getColumnByKey;
+exports.getDefaultFiltered = getDefaultFiltered;
+exports.getDefaultSort = getDefaultSort;
+exports.getNumberSize = getNumberSize;
+exports.getOrderValue = getOrderValue;
+exports.getRowHeight = getRowHeight;
+exports.getSelectableFunc = getSelectableFunc;
+exports.getSortBy = getSortBy;
+exports.getSortOrder = getSortOrder;
+exports.getSumValue = getSumValue;
+exports.getTableColumns = getTableColumns;
+exports.getTableHeight = getTableHeight;
+exports.getTreeProps = getTreeProps;
+exports.isAutoRowHeight = isAutoRowHeight;
+exports.transformTableData = transformTableData;
+exports.useAutoResize = useAutoResize;
+exports.useState = useState;

package/lib/ele-watermark/index.js

@@ -48,6 +48,10 @@ const _sfc_main = vue.defineComponent({
         opacity: "1 !important",
         transform: "none !important",
         filter: "none !important",
+        visibility: "visible !important",
+        maxWidth: "none !important",
+        maxHeight: "none !important",
+        zoom: "1 !important",
         display: "block !important",
         ...props2.customStyle
       };

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

@@ -1,17 +1,29 @@
 import type { PropType, ExtractPropTypes } from 'vue';
 import type { WatermarkGap, WatermarkOffset, WatermarkFont } from './types';
 export declare const watermarkProps: {
+    /** 宽度 */
     width: NumberConstructor;
+    /** 高度 */
     height: NumberConstructor;
+    /** 旋转角度 */
     rotate: NumberConstructor;
+    /** 层级 */
     zIndex: NumberConstructor;
+    /** 图片源 */
     image: StringConstructor;
+    /** 文字内容 */
     content: PropType<string | string[]>;
+    /** 文字样式 */
     font: PropType<WatermarkFont>;
+    /** 间距 */
     gap: PropType<WatermarkGap>;
+    /** 距离左上角的偏移量 */
     offset: PropType<WatermarkOffset>;
+    /** 自定义样式 */
     customStyle: PropType<Partial<import("vue").CSSProperties>>;
+    /** 是否使用固定定位 */
     fixed: BooleanConstructor;
+    /** 是否禁用 */
     disabled: BooleanConstructor;
 };
 export type WatermarkProps = ExtractPropTypes<typeof watermarkProps>;

package/lib/ele-watermark/props.js

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const watermarkProps = {
-  // 宽度
+  /** 宽度 */
   width: Number,
-  // 高度
+  /** 高度 */
   height: Number,
-  // 旋转角度
+  /** 旋转角度 */
   rotate: Number,
-  // 层级
+  /** 层级 */
   zIndex: Number,
-  // 图片源
+  /** 图片源 */
   image: String,
-  // 文字内容
+  /** 文字内容 */
   content: [String, Array],
-  // 文字样式
+  /** 文字样式 */
   font: Object,
-  // 间距
+  /** 间距 */
   gap: Array,
-  // 距离左上角的偏移量
+  /** 距离左上角的偏移量 */
   offset: Array,
-  // 自定义样式
+  /** 自定义样式 */
   customStyle: Object,
-  // 是否使用固定定位
+  /** 是否使用固定定位 */
   fixed: Boolean,
-  // 是否禁用
+  /** 是否禁用 */
   disabled: Boolean
 };
 exports.watermarkProps = watermarkProps;

package/lib/icons/FilterFilled.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/lib/icons/FilterFilled.js

@@ -0,0 +1,22 @@
+"use strict";
+const vue = require("vue");
+const _sfc_main = vue.defineComponent({
+  name: "FilterFilled"
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { viewBox: "0 0 1024 1024" };
+const _hoisted_2 = /* @__PURE__ */ vue.createElementVNode("path", { d: "M 349 838 c 0 17.7 14.2 32 31.8 32 h 262.4 c 17.6 0 31.8 -14.3 31.8 -32 V 642 H 349 v 196 Z M 880.1 154 H 143.9 c -24.5 0 -39.8 26.7 -27.5 48 l 221.3 376 h 348.8 l 221.3 -376 c 12.1 -21.3 -3.2 -48 -27.7 -48 Z" }, null, -1);
+const _hoisted_3 = [
+  _hoisted_2
+];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1, _hoisted_3);
+}
+const FilterFilled = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = FilterFilled;

package/lib/icons/HomeOutlined.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;