ele-admin-plus 1.0.0-beta.1

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

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("../utils/core");
+function getDefaultPage(opt) {
+  const isObj = opt != null && typeof opt === "object";
+  return isObj && opt.currentPage != null ? opt.currentPage : 1;
+}
+function getDefaultLimit(opt) {
+  const isObj = opt != null && typeof opt === "object";
+  return isObj && opt.pageSize != null ? opt.pageSize : 10;
+}
+function getValue(data, field) {
+  if (typeof field === "function") {
+    return field(data);
+  }
+  if (!field) {
+    return;
+  }
+  let value = data;
+  field.split(".").forEach((f) => {
+    value = value ? value[f] : null;
+  });
+  return value;
+}
+function getOrderItems(sorter) {
+  var _a, _b;
+  const orders = [];
+  if (!sorter || !sorter.order) {
+    return orders;
+  }
+  const descend = sorter.order === "descending";
+  const sortMethod = (_a = sorter.column) == null ? void 0 : _a.sortMethod;
+  const sortBy = (_b = sorter.column) == null ? void 0 : _b.sortBy;
+  if (Array.isArray(sortBy) && sortBy.length) {
+    sortBy.forEach((field) => {
+      if (typeof field === "string" && field.length) {
+        orders.push({ field, descend, sortMethod });
+      }
+    });
+  } else {
+    const field = typeof sortBy === "string" && sortBy ? sortBy : sorter.prop;
+    if (field) {
+      orders.push({ field, descend, sortMethod });
+    }
+  }
+  return orders;
+}
+function reloadData(datasource, sorter, page, limit) {
+  const data = sortData(datasource, sorter);
+  const total = data.length;
+  if (!page || !limit) {
+    return { page: 1, data, total };
+  }
+  const maxPage = Math.ceil(total / limit);
+  if (maxPage && page > maxPage) {
+    page = maxPage;
+  }
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  const list = data.slice(start, end > total ? total : end);
+  return { page, data: list, total };
+}
+function sortData(datasource, sorter) {
+  const data = [...datasource];
+  getOrderItems(sorter).forEach((item) => {
+    data.sort((a, b) => {
+      if (typeof item.sortMethod === "function") {
+        const r2 = item.sortMethod(a, b);
+        return item.descend ? -r2 : r2;
+      }
+      const aValue = a[item.field];
+      const bValue = b[item.field];
+      if (aValue == bValue) {
+        return 0;
+      }
+      const r = aValue < bValue ? -1 : 1;
+      return item.descend ? -r : r;
+    });
+  });
+  return data;
+}
+function getRequestFilters(filter) {
+  const filters = {};
+  Object.keys(filter).forEach((key) => {
+    const value = filter[key];
+    if (value == null) {
+      return;
+    }
+    if (typeof value === "string") {
+      if (value) {
+        filters[key] = value;
+      }
+    } else if (Array.isArray(value)) {
+      if (value.length) {
+        filters[key] = value.join(",");
+      }
+    } else {
+      filters[key] = value;
+    }
+  });
+  return filters;
+}
+function selectionIsChange(rows, selections) {
+  return rows !== selections && (selections == null || rows.length !== selections.length || rows.some((t) => !(selections && selections.includes(t))));
+}
+function getColId(column) {
+  return column ? column.columnKey || column.prop : void 0;
+}
+function getInitColumns(columns) {
+  const data = [];
+  columns.forEach((d) => {
+    var _a;
+    if (!d.hideInTable) {
+      if ((_a = d.children) == null ? void 0 : _a.length) {
+        const children = getInitColumns(d.children);
+        if (children.length) {
+          data.push({ ...d, children });
+        }
+      } else {
+        data.push({ ...d });
+      }
+    }
+  });
+  return data;
+}
+function getInitCacheColumns(columns, cacheKey, sortable) {
+  const cache = getCacheCols(cacheKey);
+  if (!cache) {
+    return getInitColumns(columns);
+  }
+  return getCheckedColumns(columns, cache.data, cache.checkedIds, sortable);
+}
+function getCheckedColumns(columns, cols, checkedIds, sortable) {
+  const data = [];
+  if (!(columns == null ? void 0 : columns.length)) {
+    return data;
+  }
+  columns.forEach((d) => {
+    const colId = getColId(d);
+    if (colId == null) {
+      return;
+    }
+    const temp = cols.find((c) => c.id === colId);
+    if (temp && !checkedIds.includes(colId)) {
+      return;
+    }
+    const fixed = (temp == null ? void 0 : temp.fixed) ?? d.fixed;
+    const id = core.uuid(8);
+    if (d.children) {
+      const children = getCheckedColumns(
+        d.children,
+        cols,
+        checkedIds,
+        sortable
+      );
+      if (children.length) {
+        data.push({ ...d, fixed, id, children });
+      }
+    } else {
+      data.push({ ...d, fixed, id });
+    }
+  });
+  if (!sortable || !data.length) {
+    return data;
+  }
+  data.sort((a, b) => {
+    var _a, _b;
+    const aColId = getColId(a);
+    const bColId = getColId(b);
+    let ai = cols.findIndex((c) => c.id === aColId);
+    let bi = cols.findIndex((c) => c.id === bColId);
+    if (ai === -1 && ((_a = a.children) == null ? void 0 : _a.length)) {
+      const colId = getColId(a.children[0]);
+      ai = cols.findIndex((c) => c.id === colId);
+    }
+    if (bi === -1 && ((_b = b.children) == null ? void 0 : _b.length)) {
+      const colId = getColId(b.children[0]);
+      bi = cols.findIndex((c) => c.id === colId);
+    }
+    if (ai === -1 && a.hideInSetting && a.fixed === "right") {
+      ai = cols.length;
+    }
+    if (a.fixed === true || a.fixed === "left") {
+      ai -= cols.length;
+    } else if (a.fixed === "right" || a.hideInSetting && !a.fixed) {
+      ai += cols.length;
+    }
+    if (bi === -1 && b.hideInSetting && b.fixed === "right") {
+      bi = cols.length;
+    }
+    if (b.fixed === true || b.fixed === "left") {
+      bi -= cols.length;
+    } else if (b.fixed === "right" || b.hideInSetting && !b.fixed) {
+      bi += cols.length;
+    }
+    return ai - bi;
+  });
+  return data;
+}
+function getSettingCols(columns, untitledText, cacheKey) {
+  const cacheResult = getCacheCols(cacheKey);
+  if (cacheResult) {
+    return cacheResult;
+  }
+  const hideTypes = ["selection", "index", "expand"];
+  const data = [];
+  core.eachTree(columns, (d) => {
+    var _a;
+    const colId = getColId(d);
+    if (colId && !((_a = d.children) == null ? void 0 : _a.length) && !d.hideInSetting && !(d.type && hideTypes.includes(d.type))) {
+      data.push({
+        id: colId,
+        prop: d.prop,
+        columnKey: d.columnKey,
+        label: d.label || untitledText,
+        checked: !d.hideInTable,
+        fixed: d.fixed
+      });
+    }
+  });
+  const checkedIds = data.filter((d) => d.checked).map((d) => d.id);
+  return {
+    data,
+    checkedIds,
+    isChecked: data.length > 0 && data.length === checkedIds.length,
+    isIndeterminate: checkedIds.length !== 0 && data.length !== checkedIds.length
+  };
+}
+function getCacheCols(cacheKey) {
+  if (!cacheKey) {
+    return;
+  }
+  const temp = localStorage.getItem(getColsCacheKey(cacheKey));
+  if (!temp) {
+    return;
+  }
+  try {
+    const data = JSON.parse(temp);
+    if (!Array.isArray(data)) {
+      return;
+    }
+    const checkedIds = data.filter((d) => d.checked).map((d) => d.id);
+    return {
+      data,
+      checkedIds,
+      isChecked: data.length > 0 && data.length === checkedIds.length,
+      isIndeterminate: checkedIds.length !== 0 && data.length !== checkedIds.length
+    };
+  } catch (_e) {
+  }
+}
+function getColsCacheKey(cacheKey) {
+  return `${cacheKey}Cols`;
+}
+function getSizeCacheKey(cacheKey) {
+  return `${cacheKey}Size`;
+}
+function getCacheSize(cacheKey) {
+  if (cacheKey) {
+    const size = localStorage.getItem(getSizeCacheKey(cacheKey));
+    if (size) {
+      return size;
+    }
+  }
+}
+function getDefaultSize(size, globalProps) {
+  return size ?? globalProps.value.size ?? "default";
+}
+function isDisableRow(row, index, columns) {
+  let disabled = false;
+  core.eachTree(columns, (col) => {
+    if (col.type === "selection" && typeof col.selectable === "function") {
+      disabled = !col.selectable(row, index);
+      return false;
+    }
+  });
+  return disabled;
+}
+function useTableMethods(getIns) {
+  return {
+    clearSelection: () => {
+      const ins = getIns();
+      ins && ins.clearSelection();
+    },
+    getSelectionRows: () => {
+      const ins = getIns();
+      if (ins) {
+        return ins.getSelectionRows();
+      }
+    },
+    toggleRowSelection: (row, selected) => {
+      const ins = getIns();
+      ins && ins.toggleRowSelection(row, selected);
+    },
+    toggleAllSelection: () => {
+      const ins = getIns();
+      ins && ins.toggleAllSelection();
+    },
+    toggleRowExpansion: (row, expanded) => {
+      const ins = getIns();
+      ins && ins.toggleRowExpansion(row, expanded);
+    },
+    setCurrentRow: (row) => {
+      const ins = getIns();
+      ins && ins.setCurrentRow(row);
+    },
+    clearSort: () => {
+      const ins = getIns();
+      ins && ins.clearSort();
+    },
+    clearFilter: (columnKeys) => {
+      const ins = getIns();
+      ins && ins.clearFilter(columnKeys);
+    },
+    doLayout: () => {
+      const ins = getIns();
+      ins && ins.doLayout();
+    },
+    sort: (prop, order) => {
+      const ins = getIns();
+      ins && ins.sort(prop, order);
+    },
+    scrollTo: (options, yCoord) => {
+      const ins = getIns();
+      ins && ins.scrollTo(options, yCoord);
+    },
+    setScrollTop: (top) => {
+      const ins = getIns();
+      ins && ins.setScrollTop(top);
+    },
+    setScrollLeft: (left) => {
+      const ins = getIns();
+      ins && ins.setScrollLeft(left);
+    }
+  };
+}
+function useTableEvents(emit) {
+  return {
+    onSelect: (selection, row) => {
+      emit("select", selection, row);
+    },
+    onSelectAll: (selection) => {
+      emit("selectAll", selection);
+    },
+    onCellMouseEnter: (row, column, cell, event) => {
+      emit("cellMouseEnter", row, column, cell, event);
+    },
+    onCellMouseLeave: (row, column, cell, event) => {
+      emit("cellMouseLeave", row, column, cell, event);
+    },
+    onCellClick: (row, column, cell, event) => {
+      emit("cellClick", row, column, cell, event);
+    },
+    onCellDblclick: (row, column, cell, event) => {
+      emit("cellDblclick", row, column, cell, event);
+    },
+    onCellContextmenu: (row, column, cell, event) => {
+      emit("cellContextmenu", row, column, cell, event);
+    },
+    onRowClick: (row, column, event) => {
+      emit("rowClick", row, column, event);
+    },
+    onRowContextmenu: (row, column, event) => {
+      emit("rowContextmenu", row, column, event);
+    },
+    onRowDblclick: (row, column, event) => {
+      emit("rowDblclick", row, column, event);
+    },
+    onHeaderClick: (column, event) => {
+      emit("headerClick", column, event);
+    },
+    onHeaderContextmenu: (column, event) => {
+      emit("headerContextmenu", column, event);
+    },
+    onHeaderDragend: (newWidth, oldWidth, column, event) => {
+      emit("headerDragend", newWidth, oldWidth, column, event);
+    },
+    onExpandChange: (row, expanded) => {
+      emit("expandChange", row, expanded);
+    },
+    onSelectionChange: (selection) => {
+      emit("selectionChange", selection);
+    },
+    onSortChange: (sorter) => {
+      emit("sortChange", sorter);
+    },
+    onFilterChange: (filter) => {
+      emit("filterChange", filter);
+    },
+    onCurrentChange: (currentRow, oldCurrentRow) => {
+      emit("currentChange", currentRow, oldCurrentRow);
+    }
+  };
+}
+exports.getCacheCols = getCacheCols;
+exports.getCacheSize = getCacheSize;
+exports.getCheckedColumns = getCheckedColumns;
+exports.getColId = getColId;
+exports.getColsCacheKey = getColsCacheKey;
+exports.getDefaultLimit = getDefaultLimit;
+exports.getDefaultPage = getDefaultPage;
+exports.getDefaultSize = getDefaultSize;
+exports.getInitCacheColumns = getInitCacheColumns;
+exports.getInitColumns = getInitColumns;
+exports.getOrderItems = getOrderItems;
+exports.getRequestFilters = getRequestFilters;
+exports.getSettingCols = getSettingCols;
+exports.getSizeCacheKey = getSizeCacheKey;
+exports.getValue = getValue;
+exports.isDisableRow = isDisableRow;
+exports.reloadData = reloadData;
+exports.selectionIsChange = selectionIsChange;
+exports.sortData = sortData;
+exports.useTableEvents = useTableEvents;
+exports.useTableMethods = useTableMethods;

package/lib/ele-qr-code/index.d.ts

@@ -0,0 +1,67 @@
+import type { CSSProperties } from 'vue';
+declare const _sfc_main: import("vue").DefineComponent<{
+    value: StringConstructor;
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    level: {
+        type: import("vue").PropType<import("./types").Level>;
+        default: string;
+    };
+    bgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    fgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    margin: {
+        type: NumberConstructor;
+        default: number;
+    };
+    imageSettings: import("vue").PropType<import("./types").ImageSettings>;
+    customStyle: import("vue").PropType<CSSProperties>;
+}, {
+    canvasRef: import("vue").Ref<HTMLCanvasElement | null>;
+    imageRef: import("vue").Ref<HTMLImageElement | null>;
+    imageSrc: import("vue").ComputedRef<string | undefined>;
+    canvasStyle: import("vue").ComputedRef<CSSProperties>;
+    render: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: () => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: StringConstructor;
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    level: {
+        type: import("vue").PropType<import("./types").Level>;
+        default: string;
+    };
+    bgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    fgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    margin: {
+        type: NumberConstructor;
+        default: number;
+    };
+    imageSettings: import("vue").PropType<import("./types").ImageSettings>;
+    customStyle: import("vue").PropType<CSSProperties>;
+}>> & {
+    onDone?: (() => any) | undefined;
+}, {
+    size: number;
+    level: import("./types").Level;
+    bgColor: string;
+    fgColor: string;
+    margin: number;
+}, {}>;
+export default _sfc_main;

package/lib/ele-qr-code/index.js

@@ -0,0 +1,152 @@
+"use strict";
+const vue = require("vue");
+const qrcodegen = require("./qrcodegen");
+const props = require("./props");
+const util = require("./util");
+const _sfc_main = vue.defineComponent({
+  name: "EleQrCode",
+  props: props.qrCodeProps,
+  emits: props.qrCodeEmits,
+  setup(props2, { emit }) {
+    const canvasRef = vue.ref(null);
+    const imageRef = vue.ref(null);
+    const imageSrc = vue.computed(
+      () => {
+        var _a;
+        return (_a = props2.imageSettings) == null ? void 0 : _a.src;
+      }
+    );
+    const canvasStyle = vue.computed(() => {
+      return {
+        height: `${props2.size}px`,
+        width: `${props2.size}px`,
+        ...props2.customStyle
+      };
+    });
+    const render = () => {
+      const { value, size, level, bgColor, fgColor, margin, imageSettings } = props2;
+      if (canvasRef.value == null) {
+        return;
+      }
+      const canvas = canvasRef.value;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        return;
+      }
+      if (!value) {
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        return;
+      }
+      let cells = qrcodegen.QrCode.encodeText(
+        value,
+        util.ERROR_LEVEL_MAP[level]
+      ).getModules();
+      const numCells = cells.length + margin * 2;
+      const calculatedImageSettings = util.getImageSettings(
+        imageSettings,
+        size,
+        margin,
+        cells
+      );
+      const image = imageRef.value;
+      const haveImageToRender = calculatedImageSettings != null && image != null && image.complete && image.naturalHeight !== 0 && image.naturalWidth !== 0;
+      if (haveImageToRender && calculatedImageSettings.excavation != null) {
+        cells = util.excavateModules(cells, calculatedImageSettings.excavation);
+      }
+      const pixelRatio = window.devicePixelRatio || 1;
+      canvas.height = canvas.width = size * pixelRatio;
+      const scale = size / numCells * pixelRatio;
+      ctx.scale(scale, scale);
+      ctx.fillStyle = bgColor;
+      ctx.fillRect(0, 0, numCells, numCells);
+      ctx.fillStyle = fgColor;
+      if (util.SUPPORTS_PATH2D) {
+        ctx.fill(new Path2D(util.generatePath(cells, margin)));
+      } else {
+        cells.forEach(function(row, rdx) {
+          row.forEach(function(cell, cdx) {
+            if (cell) {
+              ctx.fillRect(cdx + margin, rdx + margin, 1, 1);
+            }
+          });
+        });
+      }
+      if (haveImageToRender) {
+        ctx.drawImage(
+          image,
+          calculatedImageSettings.x + margin,
+          calculatedImageSettings.y + margin,
+          calculatedImageSettings.w,
+          calculatedImageSettings.h
+        );
+      }
+      emit("done");
+    };
+    vue.watch(
+      [
+        () => props2.value,
+        () => props2.level,
+        () => props2.bgColor,
+        () => props2.fgColor,
+        () => props2.margin
+      ],
+      () => {
+        render();
+      }
+    );
+    vue.watch(
+      () => props2.size,
+      () => {
+        vue.nextTick(() => {
+          render();
+        });
+      }
+    );
+    vue.watch(
+      () => props2.imageSettings,
+      () => {
+        render();
+      },
+      { deep: true }
+    );
+    vue.onMounted(() => {
+      render();
+    });
+    return {
+      canvasRef,
+      imageRef,
+      imageSrc,
+      canvasStyle,
+      render
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-qr-code" };
+const _hoisted_2 = ["height", "width"];
+const _hoisted_3 = ["src"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("span", _hoisted_1, [
+    vue.createElementVNode("canvas", {
+      ref: "canvasRef",
+      height: _ctx.size,
+      width: _ctx.size,
+      style: vue.normalizeStyle(_ctx.canvasStyle)
+    }, null, 12, _hoisted_2),
+    _ctx.imageSrc ? (vue.openBlock(), vue.createElementBlock("img", {
+      key: 0,
+      ref: "imageRef",
+      src: _ctx.imageSrc,
+      style: { display: "none" },
+      onLoad: _cache[0] || (_cache[0] = (...args) => _ctx.render && _ctx.render(...args))
+    }, null, 40, _hoisted_3)) : vue.createCommentVNode("", true)
+  ]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

package/lib/ele-qr-code/props.d.ts

@@ -0,0 +1,37 @@
+import type { PropType, CSSProperties, ExtractPropTypes } from 'vue';
+import type { Level, ImageSettings } from './types';
+/**
+ * 属性
+ */
+export declare const qrCodeProps: {
+    value: StringConstructor;
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    level: {
+        type: PropType<Level>;
+        default: string;
+    };
+    bgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    fgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    margin: {
+        type: NumberConstructor;
+        default: number;
+    };
+    imageSettings: PropType<ImageSettings>;
+    customStyle: PropType<CSSProperties>;
+};
+export type QrCodeProps = ExtractPropTypes<typeof qrCodeProps>;
+/**
+ * 事件
+ */
+export declare const qrCodeEmits: {
+    done: () => boolean;
+};

package/lib/ele-qr-code/props.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const qrCodeProps = {
+  // 绑定值
+  value: String,
+  // 尺寸
+  size: {
+    type: Number,
+    default: 128
+  },
+  // 容错等级
+  level: {
+    type: String,
+    default: "L"
+  },
+  // 背景色
+  bgColor: {
+    type: String,
+    default: "#FFFFFF"
+  },
+  // 颜色
+  fgColor: {
+    type: String,
+    default: "#000000"
+  },
+  // 外间距
+  margin: {
+    type: Number,
+    default: 0
+  },
+  // 自定义图片
+  imageSettings: Object,
+  // 自定义样式
+  customStyle: Object
+};
+const qrCodeEmits = {
+  // 渲染完成事件
+  done: () => true
+};
+exports.qrCodeEmits = qrCodeEmits;
+exports.qrCodeProps = qrCodeProps;