el-plus2 0.0.0

package/dist/index.full.js

@@ -0,0 +1,2204 @@
+/*! ElPlus vundefined */
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('element-plus'), require('axios'), require('element-plus/es/components/message/style/css'), require('element-plus/es/components/loading/style/css'), require('element-plus/es/components/table/src/table/defaults')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vue', 'element-plus', 'axios', 'element-plus/es/components/message/style/css', 'element-plus/es/components/loading/style/css', 'element-plus/es/components/table/src/table/defaults'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ElPlus = {}, global.Vue, global.ElementPlus, global.axios, null, null, global.elTableProps));
+})(this, (function (exports, vue, elementPlus, axios, css, css$1, elTableProps) { 'use strict';
+
+  const buttonsProps = {
+    ...elementPlus.buttonProps,
+    disabled: {
+      type: [Boolean, Function]
+    },
+    list: {
+      type: Array,
+      default: () => []
+    },
+    size: {
+      ...elementPlus.buttonProps.size,
+      default: "small"
+    },
+    type: {
+      ...elementPlus.buttonProps.type,
+      default: "default"
+    }
+  };
+
+  function _bem(prefix, block, element, modifier) {
+    if (block) {
+      prefix += "-" + block;
+    }
+    if (element) {
+      prefix += "__" + element;
+    }
+    if (modifier) {
+      prefix += "--" + modifier;
+    }
+    return prefix;
+  }
+  function createBEM(prefix) {
+    return {
+      b: (block = "") => _bem(prefix, block, "", ""),
+      e: (element = "") => element ? _bem(prefix, "", element, "") : "",
+      m: (modifier = "") => modifier ? _bem(prefix, "", "", modifier) : "",
+      be: (block = "", element = "") => block && element ? _bem(prefix, block, element, "") : "",
+      bm: (block = "", modifier = "") => block && modifier ? _bem(prefix, block, "", modifier) : "",
+      em: (element = "", modifier = "") => element && modifier ? _bem(prefix, "", element, modifier) : "",
+      bem: (block = "", element = "", modifier) => block && element && modifier ? _bem(prefix, block, element, modifier) : "",
+      is: (name = "", state) => state ? `is-${name}` : ""
+    };
+  }
+  function createNameSpace(name) {
+    const prefix = `ep-${name}`;
+    return createBEM(prefix);
+  }
+
+  const apiProps = {
+    api: {
+      type: [String, Function]
+    },
+    method: {
+      type: String
+    },
+    reqData: {
+      type: Object
+    },
+    reqParams: {
+      type: Object
+    },
+    reqBefore: {
+      type: Function
+    },
+    reqAfter: {
+      type: Function
+    }
+  };
+  const visibleProps = {
+    show: {
+      type: [Boolean, Function]
+    },
+    hide: {
+      type: [Boolean, Function]
+    }
+  };
+  const prepareProps = (props, excludeKeys = []) => {
+    return Object.keys(props).reduce((acc, key) => {
+      if (!excludeKeys.includes(key)) {
+        acc[key] = props[key];
+      }
+      return acc;
+    }, {});
+  };
+  const prepareEvents = (emit, eventKeys) => {
+    return eventKeys.reduce(
+      (acc, key) => {
+        let eventName;
+        if (key.startsWith("on")) {
+          eventName = key;
+        } else {
+          if (key.includes("-")) {
+            eventName = "on" + key.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+          } else {
+            eventName = `on${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+          }
+        }
+        acc[eventName] = (...args) => emit(key, ...args);
+        return acc;
+      },
+      {}
+    );
+  };
+  const prepareClassNames = () => {
+    return vue.useAttrs().class || "";
+  };
+  const prepareStyles = () => {
+    return vue.useAttrs().style || {};
+  };
+
+  const SCOPE = "_RepeatClick";
+  const vRepeatClick = {
+    name: "repeatClick",
+    // 在绑定元素的 attribute 前
+    // 或事件监听器应用前调用
+    // created(el, binding, vnode) {
+    //   // el.style.display = 'none'
+    //   // 下面会介绍各个参数的细节
+    //   console.log('created', el, binding, vnode)
+    // },
+    // 在元素被插入到 DOM 前调用
+    beforeMount(el, binding) {
+      const { delay = 300, immediate } = typeof binding.value === "object" ? binding.value : {};
+      const handler = typeof binding.value === "object" ? binding.value.handler : binding.value;
+      let isPending = false;
+      let timer;
+      const start = (e) => {
+        if (e.button !== 0) return;
+        timer && clearTimeout(timer);
+        timer = setTimeout(() => {
+          if (immediate) {
+            isPending = false;
+          } else {
+            handler?.(e);
+          }
+        }, delay);
+        if (immediate) {
+          if (isPending) {
+            return;
+          }
+          isPending = true;
+          handler?.(e);
+        }
+      };
+      el[SCOPE] = { start };
+      el.addEventListener("click", start);
+    },
+    //   // 在绑定元素的父组件
+    //   // 及他自己的所有子节点都挂载完成后调用
+    //   mounted(el, binding, vnode) {
+    //     console.log('mounted', el, binding, vnode)
+    //   },
+    //   // 绑定元素的父组件更新前调用
+    //   beforeUpdate(el, binding, vnode, prevVnode) {
+    //     console.log('beforeUpdate', el, binding, vnode, prevVnode)
+    //   },
+    //   // 在绑定元素的父组件
+    //   // 及他自己的所有子节点都更新后调用
+    //   updated(el, binding, vnode, prevVnode) {
+    //     console.log('updated', el, binding, vnode, prevVnode)
+    //   },
+    //   // 绑定元素的父组件卸载前调用
+    //   beforeUnmount(el, binding, vnode) {
+    //     console.log('beforeUnmount', el, binding, vnode)
+    //   },
+    // 绑定元素的父组件卸载后调用
+    unmounted(el) {
+      if (!el[SCOPE]) return;
+      const { start } = el[SCOPE];
+      if (start) {
+        el.removeEventListener("mousedown", start);
+      }
+      el[SCOPE] = null;
+    }
+  };
+
+  const getEnv = (mark = "hxjf", hostname = window.location.hostname) => {
+    const tag = hostname.match(new RegExp(`.*(?=${mark})`));
+    if (hostname === "hxdv-ui.hongxinshop.com") {
+      return "production";
+    }
+    if (!tag) {
+      return "local";
+    }
+    return tag[0] ? tag[0].replace("-", "") : "production";
+  };
+  const getBaseUrl = (env = "sit", isOpenApi) => {
+    let url = "";
+    if (getEnv() === "local") {
+      const query = {};
+      query.devProxy = location.search.slice(1).split("=")[1] || location.hash.slice(1).split("=")[1];
+      const devProxy = query.devProxy || `${env}-api`;
+      url = `${devProxy}${""}`;
+    } else {
+      url = "/vue-api";
+    }
+    return url;
+  };
+
+  const getCookie = (name) => {
+    const reg = new RegExp("(^| )" + name + "=([^;]*)(;|$)");
+    const arr = document.cookie.match(reg);
+    if (arr) {
+      return decodeURIComponent(arr[2]);
+    }
+    return null;
+  };
+
+  const instance = axios.create({
+    method: "post",
+    timeout: 2e4,
+    baseURL: getBaseUrl(),
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  let reqNum = 0;
+  let loading = { close: () => {
+  } };
+  function startLoading() {
+    if (reqNum === 0) {
+      loading = elementPlus.ElLoading.service({
+        fullscreen: true,
+        lock: true,
+        text: "\u8BF7\u7A0D\u7B49\uFF0C\u6B63\u5728\u52A0\u8F7D\u4E2D...",
+        spinner: "el-icon-loading",
+        background: "rgba(0,0,0,0.7)"
+      });
+    }
+    reqNum++;
+  }
+  function closeLoading() {
+    if (reqNum <= 0) {
+      return;
+    }
+    reqNum--;
+    if (reqNum === 0) {
+      loading.close();
+    }
+  }
+  function endLoading() {
+    closeLoading();
+  }
+  instance.interceptors.request.use(
+    async (config) => {
+      const token = getCookie("access_token");
+      if (token) {
+        config.headers["Authorization"] = `Bearer ${token}`;
+      }
+      if (config.loading) {
+        startLoading();
+      }
+      config.headers = {
+        ...config.headers,
+        ...window.hx && window.hx.getSignHeaders({
+          // 只有openapi接口需要传sign
+          sign: config.sign || window.ELPLUSSIGN,
+          config
+        })
+      };
+      const cancelRequest = config.cancelRequest;
+      config.cancelToken = new axios.CancelToken(function(cancel) {
+        cancelRequest && cancelRequest(cancel);
+      });
+      return config;
+    },
+    (error) => {
+      console.log(error);
+      return Promise.reject(error);
+    }
+  );
+  instance.interceptors.response.use(
+    (response) => {
+      const config = response.config;
+      if (config.loading) {
+        endLoading();
+      }
+      const responseCode = response.data.code;
+      const { hideToast, hideToastCode = {} } = response.config.headers;
+      hideToastCode.length = Object.keys(hideToastCode).length;
+      if (responseCode === 200) {
+        return Promise.resolve(response.data);
+      } else if (hideToast || Array.prototype.slice.call(hideToastCode).indexOf(responseCode) > -1) {
+        return Promise.reject(response.data);
+      } else {
+        setTimeout(() => {
+          elementPlus.ElMessage.error({
+            message: `<pre>${response.data.msg}</pre>`,
+            type: "error",
+            duration: 2e3,
+            dangerouslyUseHTMLString: true
+          });
+        }, 300);
+        return Promise.reject(response.data);
+      }
+    },
+    (error) => {
+      const { config = {}, message } = error;
+      const { url } = config;
+      if (config.loading) {
+        endLoading();
+      }
+      if (error && error.response) {
+        const { status } = error.response;
+        switch (status) {
+          case 400:
+            error.message = error.response.data.message || error.response.data.msg;
+            break;
+          case 403:
+            error.message = "\u62D2\u7EDD\u8BBF\u95EE(403)";
+            break;
+          case 404:
+            error.message = "\u8BF7\u6C42\u51FA\u9519(404)";
+            break;
+          case 408:
+            error.message = "\u8BF7\u6C42\u8D85\u65F6(408)";
+            break;
+          case 500:
+            error.message = "\u670D\u52A1\u5668\u9519\u8BEF(500)";
+            break;
+          case 501:
+            error.message = "\u670D\u52A1\u672A\u5B9E\u73B0(501)";
+            break;
+          case 502:
+            error.message = "\u7F51\u7EDC\u9519\u8BEF(502)";
+            break;
+          case 503:
+            error.message = "\u670D\u52A1\u4E0D\u53EF\u7528(503)";
+            break;
+          case 504:
+            error.message = "\u7F51\u7EDC\u8D85\u65F6(504)";
+            break;
+          case 505:
+            error.message = "HTTP\u7248\u672C\u4E0D\u53D7\u652F\u6301(505)";
+            break;
+          default:
+            error.message = `\u8FDE\u63A5\u51FA\u9519(${error.response.status})!`;
+        }
+      } else {
+        if (error.message.includes("timeout")) {
+          error.message = `\u8BF7\u6C42${url ? url : ""}\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u662F\u5426\u8FDE\u63A5\u6B63\u5E38`;
+        } else {
+          error.message = `\u8BF7\u6C42${url ? url : ""}\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u662F\u5426\u5DF2\u8FDE\u63A5`;
+        }
+      }
+      if (!axios.isCancel(error) || !config.noErrorMsg) {
+        elementPlus.ElMessage.error({
+          message: error.message,
+          type: "error",
+          duration: 2e3,
+          dangerouslyUseHTMLString: true
+        });
+      }
+      return Promise.reject(error);
+    }
+  );
+  const fetch = instance.request;
+
+  const vPermisson = {
+    name: "permission",
+    mounted(el, binding) {
+      const { arg, value } = binding.value;
+      if (!arg && !value) {
+        return;
+      }
+      el.style.display = "none";
+      const permission = `${arg}:${value}`;
+      checkPermission(permission, el);
+    },
+    updated(el, binding) {
+      const { arg, value } = binding.value;
+      if (!arg && !value) {
+        if (el.style.display === "none") {
+          el.style.display = "";
+        }
+        return;
+      }
+      const permission = `${arg}:${value}`;
+      checkPermission(permission, el);
+    }
+  };
+  async function checkPermission(permission, el) {
+    const { data: roles = [] } = await queryRoles();
+    const hasPermission = roles.indexOf(permission) > -1;
+    if (!hasPermission) {
+      el && el.parentNode && el.parentNode.removeChild(el);
+    } else {
+      el.style.display = "";
+    }
+    return hasPermission;
+  }
+  let requestPromise = null;
+  async function queryRoles() {
+    try {
+      if (requestPromise) {
+        return requestPromise;
+      }
+      requestPromise = fetch({
+        url: "/api-u/api/saas/user/appButtonRoleList",
+        loading: true,
+        noErrorMsg: true
+      });
+      return requestPromise;
+    } catch (error) {
+      console.error(error);
+      return { data: [] };
+    }
+  }
+
+  const bem$1 = createNameSpace("button");
+  var Buttons$1 = /* @__PURE__ */ vue.defineComponent({
+    name: "EpButtons",
+    directives: {
+      [vRepeatClick.name]: vRepeatClick,
+      [vPermisson.name]: vPermisson
+    },
+    inheritAttrs: false,
+    props: buttonsProps,
+    setup(props, {
+      emit
+    }) {
+      const {
+        list,
+        ...buttonProps
+      } = props;
+      const customList = vue.computed(() => {
+        return list.filter((button) => {
+          if ("show" in button) {
+            return typeof button.show === "function" ? button.show(button) : button.show;
+          } else if ("hide" in button) {
+            return typeof button.hide === "function" ? !button.hide(button) : !button.hide;
+          }
+          return true;
+        });
+      });
+      const clickFn = async (item) => {
+        if (item.confirm) {
+          const confirmText = item.confirmText || `\u786E\u5B9A\u8981${item.name}\u5417\uFF1F`;
+          await elementPlus.ElMessageBox.confirm(confirmText, "Warning", {
+            confirmButtonText: "\u786E\u5B9A",
+            cancelButtonText: "\u53D6\u6D88",
+            type: "warning"
+          });
+        }
+        item.onClick();
+      };
+      return () => vue.createVNode(vue.Fragment, null, [customList.value.map((item) => {
+        const permissionArr = item.permission?.split(":") || [];
+        return vue.withDirectives(vue.createVNode(vue.resolveComponent("el-button"), vue.mergeProps({
+          "class": [bem$1.b(), prepareClassNames()],
+          "style": prepareStyles(),
+          "key": item.prop || item.name
+        }, {
+          ...prepareProps(buttonProps),
+          ...prepareProps(item, ["scopedSlots", "name", "onClick"])
+        }), {
+          default: () => item.name,
+          ...item.scopedSlots
+        }), [[vue.resolveDirective("repeat-click"), typeof item.onClick === "function" ? {
+          handler: () => clickFn(item),
+          immediate: true
+        } : () => clickFn(item)], [vue.resolveDirective("permission"), {
+          arg: permissionArr[0],
+          value: permissionArr[1]
+        }]]);
+      })]);
+    }
+  });
+
+  function withInstall(comp) {
+    comp.install = (app) => {
+      app.component(comp.name, comp);
+    };
+    return comp;
+  }
+
+  var Buttons = withInstall(Buttons$1);
+
+  const expandFormProps = {
+    // 表单列表
+    formItemList: {
+      type: Array,
+      default: () => []
+    },
+    // 是否显示折叠
+    isShowFold: Boolean,
+    // 最大显示的表单数
+    showFieldCount: {
+      type: Number,
+      default: 8
+    },
+    // 每行的列数
+    col: {
+      type: Number,
+      default: 4
+    }
+  };
+  const formProps = {
+    ...elementPlus.formProps,
+    ...expandFormProps,
+    size: {
+      ...elementPlus.formProps.size,
+      default: "small"
+    },
+    // 标签的长度
+    labelWidth: {
+      ...elementPlus.formProps.labelWidth,
+      default: 120
+    },
+    scrollIntoViewOptions: {
+      ...elementPlus.formProps.scrollIntoViewOptions,
+      default: () => {
+        return { inline: "center" };
+      }
+    }
+  };
+  const expandFormPropsKeys = Object.keys(expandFormProps);
+  const formEmits = {
+    ...elementPlus.formEmits,
+    toggleStatus: (status) => true
+    // 折叠状态切换时触发
+  };
+  const formEmitsKeys = Object.keys(formEmits);
+
+  const useCollapse = ({ isShowFold, showFieldCount, filterFormItemList }, emit) => {
+    const open = vue.ref(false);
+    const toggleStatus = () => {
+      open.value = !open.value;
+      emit("toggleStatus", open.value);
+    };
+    const isShowFoldBtn = vue.computed(() => {
+      return isShowFold && filterFormItemList.value.length > showFieldCount;
+    });
+    const isShowFormItem = (index) => {
+      return index < showFieldCount || open.value || !isShowFoldBtn.value;
+    };
+    return {
+      open,
+      toggleStatus,
+      isShowFoldBtn,
+      isShowFormItem
+    };
+  };
+  const useForm$1 = (props) => {
+    const elFormRef = vue.useTemplateRef("elFormRef");
+    const filterFormItemList = vue.computed(() => {
+      return props.formItemList.filter((item) => {
+        if ("show" in item) {
+          return typeof item.show === "function" ? item.show(item) : item.show;
+        } else if ("hide" in item) {
+          return typeof item.hide === "function" ? !item.hide(item) : !item.hide;
+        }
+        return true;
+      });
+    });
+    const validate = () => {
+      return elFormRef.value.validate();
+    };
+    const resetFields = (props2) => {
+      return elFormRef.value.resetFields(props2);
+    };
+    const clearValidate = (props2) => {
+      return elFormRef.value.clearValidate(props2);
+    };
+    return {
+      filterFormItemList,
+      elFormRef,
+      validate,
+      resetFields,
+      clearValidate
+    };
+  };
+
+  const useFormItemSlots = (props) => {
+    const attrs = vue.useAttrs();
+    const {
+      type,
+      label,
+      render,
+      required,
+      labelRender
+    } = props;
+    const prop = props.tableProp || props.prop;
+    const {
+      scopedSlots: renderScopedSlots,
+      ...renderProps
+    } = props.props || {};
+    const events = {};
+    for (const key in attrs) {
+      if (key.startsWith("on")) {
+        events[key] = attrs[key];
+      }
+    }
+    const formData = attrs["form-data"];
+    const scopedSlots = {
+      default: () => {
+        return type ? vue.h(vue.resolveComponent(type), {
+          modelValue: formData[prop],
+          "onUpdate:modelValue": (value) => {
+            formData[prop] = value;
+          },
+          ...renderProps,
+          ...events
+        }, renderScopedSlots) : formData[prop];
+      },
+      label: () => {
+        return vue.createVNode(vue.resolveComponent("el-tooltip"), {
+          "placement": "top",
+          "effect": "light",
+          "content": label,
+          "disabled": !props.isShowLabel
+        }, {
+          default: () => [vue.createVNode("span", null, [!props.hideRequiredAsterisk && required ? vue.createVNode("span", {
+            "style": "color: var(--el-color-danger);"
+          }, [vue.createTextVNode("*")]) : null, props.isShowLabel ? vue.createVNode("span", null, [label]) : ""])]
+        });
+      }
+    };
+    if (labelRender) {
+      scopedSlots.label = () => labelRender({
+        label
+      });
+    }
+    if (render) {
+      scopedSlots.default = render;
+    }
+    return {
+      scopedSlots
+    };
+  };
+  const useFormItemRules = (props) => {
+    const {
+      required,
+      rules,
+      label
+    } = props;
+    let mergeRules = [];
+    if (required) {
+      const requiredDefault = {
+        required: true
+      };
+      mergeRules.push(requiredDefault);
+    }
+    if (rules) {
+      if (Array.isArray(rules)) {
+        mergeRules = mergeRules.concat(rules);
+      }
+      if (Object.prototype.toString.call(rules) === "[object Object]") {
+        mergeRules.push(rules);
+      }
+    }
+    if (mergeRules) {
+      mergeRules.forEach((r) => {
+        if (r.required && typeof r.message === "undefined") {
+          r.message = `${label || ""}\u4E0D\u80FD\u4E3A\u7A7A`;
+        }
+      });
+    }
+    return {
+      rules: mergeRules
+    };
+  };
+
+  const expandFormItemProps = {
+    type: {
+      type: String
+      // default: 'EpInput',
+    },
+    col: Number,
+    render: Function,
+    labelRender: Function,
+    props: Object,
+    ...visibleProps,
+    class: String,
+    style: {
+      type: [String, Object]
+    },
+    isShowLabel: {
+      type: Boolean,
+      default: true
+    },
+    hideRequiredAsterisk: Boolean,
+    tableProp: String
+    // 用于table里的表单需要绑定的prop
+  };
+  const formItemProps = {
+    ...elementPlus.formItemProps,
+    ...expandFormItemProps
+  };
+  const expandFormItemPropsKeys = Object.keys(expandFormItemProps);
+
+  const bem = createNameSpace("form-item");
+  var EpFormItem = /* @__PURE__ */ vue.defineComponent({
+    name: "EpFormItem",
+    inheritAttrs: false,
+    props: formItemProps,
+    setup(props, {
+      emit
+    }) {
+      const attrs = vue.useAttrs();
+      const {
+        scopedSlots
+      } = useFormItemSlots(props);
+      const {
+        rules
+      } = useFormItemRules(props);
+      const {
+        props: childProps,
+        ...formItemProps2
+      } = props;
+      return () => {
+        return vue.createVNode(vue.resolveComponent("el-form-item"), vue.mergeProps({
+          "class": [bem.b(), prepareClassNames()],
+          "style": prepareStyles()
+        }, {
+          ...prepareProps(formItemProps2, [...expandFormItemPropsKeys]),
+          rules,
+          "label-width": attrs["form-label-width"]
+        }), scopedSlots);
+      };
+    }
+  });
+
+  var _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
+    ...{
+      name: "EpForm",
+      inheritAttrs: false
+    },
+    __name: "form",
+    props: /* @__PURE__ */ vue.mergeModels(formProps, {
+      "modelValue": { type: Object, ...{
+        default: () => vue.reactive({})
+      } },
+      "modelModifiers": {}
+    }),
+    emits: /* @__PURE__ */ vue.mergeModels(formEmits, ["update:modelValue"]),
+    setup(__props, { expose: __expose, emit: __emit }) {
+      const bem = createNameSpace("form");
+      const props = __props;
+      const emit = __emit;
+      const customAttrs = vue.computed(() => {
+        return {
+          ...prepareProps(props, ["modelValue", "model", ...expandFormPropsKeys]),
+          hideRequiredAsterisk: true,
+          // 隐藏必填星号, 使用自己的*
+          scrollToError: true,
+          ...prepareEvents(emit, formEmitsKeys)
+        };
+      });
+      const formData = vue.useModel(__props, "modelValue");
+      const { filterFormItemList, elFormRef, validate, resetFields, clearValidate } = useForm$1(props);
+      const { open, toggleStatus, isShowFoldBtn, isShowFormItem } = useCollapse(
+        {
+          filterFormItemList,
+          isShowFold: props.isShowFold,
+          showFieldCount: props.showFieldCount
+        },
+        emit
+      );
+      __expose({
+        elFormRef,
+        validate,
+        resetFields,
+        clearValidate
+      });
+      return (_ctx, _cache) => {
+        const _component_el_col = vue.resolveComponent("el-col");
+        const _component_el_row = vue.resolveComponent("el-row");
+        const _component_el_form = vue.resolveComponent("el-form");
+        return vue.openBlock(), vue.createElementBlock(
+          "div",
+          {
+            class: vue.normalizeClass([
+              vue.unref(bem).b(),
+              vue.unref(prepareClassNames)(),
+              vue.unref(bem).is("open", vue.unref(open)),
+              vue.unref(bem).is("fold", vue.unref(isShowFoldBtn))
+            ]),
+            style: vue.normalizeStyle({
+              ...vue.unref(prepareStyles)()
+            })
+          },
+          [
+            vue.createVNode(_component_el_form, vue.mergeProps({
+              ref_key: "elFormRef",
+              ref: elFormRef,
+              model: formData.value
+            }, customAttrs.value), {
+              default: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "default", {}, () => [
+                  vue.createVNode(_component_el_row, null, {
+                    default: vue.withCtx(() => [
+                      (vue.openBlock(true), vue.createElementBlock(
+                        vue.Fragment,
+                        null,
+                        vue.renderList(vue.unref(filterFormItemList), (item, index) => {
+                          return vue.withDirectives((vue.openBlock(), vue.createBlock(_component_el_col, {
+                            key: item.prop || index,
+                            class: vue.normalizeClass(vue.unref(bem).e("col")),
+                            span: item.col || 24 / _ctx.col
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(EpFormItem), vue.mergeProps({
+                                "form-data": formData.value,
+                                "form-label-width": _ctx.labelWidth
+                              }, { ref_for: true }, item), null, 16, ["form-data", "form-label-width"])
+                            ]),
+                            _: 2
+                            /* DYNAMIC */
+                          }, 1032, ["class", "span"])), [
+                            [vue.vShow, vue.unref(isShowFormItem)(index)]
+                          ]);
+                        }),
+                        128
+                        /* KEYED_FRAGMENT */
+                      ))
+                    ]),
+                    _: 1
+                    /* STABLE */
+                  })
+                ])
+              ]),
+              _: 3
+              /* FORWARDED */
+            }, 16, ["model"]),
+            vue.unref(isShowFoldBtn) ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              class: vue.normalizeClass(vue.unref(bem).e("fold")),
+              onClick: vue.unref(toggleStatus)
+            }, vue.toDisplayString(vue.unref(open) ? "\u6536\u8D77" : "\u66F4\u591A"), 11, ["onClick"])) : vue.createCommentVNode("v-if", true)
+          ],
+          6
+          /* CLASS, STYLE */
+        );
+      };
+    }
+  });
+
+  var Form = withInstall(_sfc_main$4);
+
+  const inputProps = {
+    ...elementPlus.inputProps,
+    max: Number,
+    min: Number,
+    radix: Number,
+    nonzero: Boolean,
+    placeholder: {
+      type: String,
+      default: "\u8BF7\u8F93\u5165"
+    },
+    thousand: {
+      type: Boolean,
+      default: true
+    },
+    clearable: {
+      ...elementPlus.inputProps.clearable,
+      default: true
+    }
+  };
+  const inputEmits = {
+    ...elementPlus.inputEmits
+  };
+  const inputEmitsKeys = Object.keys(inputEmits);
+
+  var _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+    ...{
+      name: "EpInput",
+      inheritAttrs: false
+    },
+    __name: "input",
+    props: /* @__PURE__ */ vue.mergeModels(inputProps, {
+      "modelValue": { type: null },
+      "modelModifiers": {}
+    }),
+    emits: /* @__PURE__ */ vue.mergeModels(inputEmits, ["update:modelValue"]),
+    setup(__props, { emit: __emit }) {
+      const bem = createNameSpace("input");
+      const props = __props;
+      const emit = __emit;
+      const slots = vue.computed(() => {
+        return Object.keys(vue.useSlots());
+      });
+      let isBluring = false;
+      let isFocusing = false;
+      const customAttrs = vue.computed(() => {
+        return {
+          ...prepareProps(props, ["modelValue"]),
+          ...prepareEvents(emit, inputEmitsKeys),
+          placeholder: props.disabled ? "" : props.placeholder,
+          onFocus: (e) => {
+            isFocusing = true;
+            if (props.thousand) {
+              e.target.value = value.value ? String(value.value) : "";
+            }
+            emit("focus", e);
+          },
+          onBlur: (e) => {
+            if (props.type === "number") {
+              let val = value.value;
+              if (props.nonzero && +val === 0) {
+                val = "";
+              }
+              if (val && val[val.length - 1] === ".") {
+                val = String(val).slice(0, -1);
+              }
+              if (val && val === "-") {
+                val = "";
+              }
+              value.value = val ? +val : val;
+              e.target.value = toThousand(value.value);
+            }
+            isBluring = true;
+            isFocusing = false;
+            emit("blur", e);
+          }
+        };
+      });
+      const value = vue.useModel(__props, "modelValue");
+      const inputRef = vue.ref();
+      const toThousand = (val) => {
+        if (props.thousand) {
+          return val ? window.hx.thousand(val) : val;
+        }
+        return val;
+      };
+      vue.watch(
+        () => value.value,
+        (val) => {
+          if (props.type === "number") {
+            vue.onMounted(() => {
+              inputRef.value.input.value = toThousand(val);
+            });
+          }
+          if (isBluring) {
+            isBluring = false;
+            return;
+          }
+          if (!isFocusing) {
+            return;
+          }
+          if (props.type === "number") {
+            if (typeof val === "number") {
+              val = "" + val;
+            }
+            if (typeof val === "string") {
+              const zeroReg = new RegExp("^[-+]?0[0-9]\\d*");
+              if (zeroReg.test(val)) {
+                val = val.replace("0", "");
+              }
+              const reg = new RegExp("^([-+])?\\d*(\\.?\\d*)", "g");
+              val = val.match(reg) ? val.match(reg)[0] : "";
+              if (props.radix || props.radix === 0) {
+                const reg2 = props.radix === 0 ? new RegExp("^([-+])?\\d*", "g") : new RegExp(`^([-+])?\\d*(\\.?\\d{0,${props.radix}})`, "g");
+                val = val.match(reg2) ? val.match(reg2)[0] : "";
+              }
+              if ((props.max || props.max === 0) && +val > props.max) {
+                val = props.max;
+              }
+              if ((props.min || props.min === 0) && (val || val === 0) && +val < props.min) {
+                val = props.min;
+              }
+            }
+          } else if (props.type === "text") {
+            val = val.trim();
+          }
+          value.value = val;
+        },
+        {
+          immediate: true
+        }
+      );
+      return (_ctx, _cache) => {
+        const _component_el_input = vue.resolveComponent("el-input");
+        return vue.openBlock(), vue.createBlock(_component_el_input, vue.mergeProps({
+          ref_key: "inputRef",
+          ref: inputRef,
+          modelValue: value.value,
+          "onUpdate:modelValue": ($event) => value.value = $event,
+          class: `${vue.unref(bem).b()} ${vue.unref(prepareClassNames)()}`,
+          style: {
+            ...vue.unref(prepareStyles)()
+          }
+        }, customAttrs.value, {
+          type: _ctx.type === "number" ? "text" : _ctx.type
+        }), vue.createSlots({
+          _: 2
+          /* DYNAMIC */
+        }, [
+          vue.renderList(slots.value, (name) => {
+            return {
+              name,
+              fn: vue.withCtx((scope) => [
+                vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(scope)))
+              ])
+            };
+          })
+        ]), 1040, ["modelValue", "onUpdate:modelValue", "class", "style", "type"]);
+      };
+    }
+  });
+
+  var Input = withInstall(_sfc_main$3);
+
+  const inheritTableProps = {
+    ...elTableProps,
+    // Table 的尺寸
+    size: {
+      ...elTableProps.size,
+      default: "default"
+    },
+    // 是否带有纵向边框
+    border: {
+      ...elTableProps.border,
+      default: true
+    },
+    // 表头样式
+    headerCellStyle: {
+      ...elTableProps.headerCellStyle,
+      default: () => ({
+        background: "#EEEFF3",
+        // textAlign: 'center',
+        fontSize: "14px",
+        color: "#505050"
+      })
+    }
+  };
+  const expandTableProps = {
+    ...apiProps,
+    columns: {
+      type: Array,
+      default: () => []
+    },
+    // 是否显示勾选列
+    showSelectionCol: Boolean,
+    // 是否显示序号列
+    showIndexCol: {
+      type: Boolean,
+      default: true
+    },
+    // 对齐方式
+    align: {
+      type: String,
+      default: "center"
+    },
+    // 序号列自定义
+    indexFormatter: {
+      type: [Number, Function]
+    },
+    disabled: Boolean,
+    reserveSelection: Boolean,
+    selectable: {
+      type: Function
+    },
+    paginationProps: {
+      type: Object,
+      default: () => ({})
+    },
+    showPagination: Boolean,
+    isFrontPage: Boolean,
+    // 操作列
+    actionButtons: {
+      type: Array,
+      default: () => []
+    },
+    // 链接列
+    linkProps: {
+      type: Array,
+      default: () => []
+    }
+  };
+  const tableProps = {
+    ...inheritTableProps,
+    ...expandTableProps
+  };
+  const expandTablePropsKeys = Object.keys(expandTableProps);
+  const tableEmits = elementPlus.ElTable.emits;
+  const tableEmitsKeys = tableEmits;
+
+  const useRequest = ({
+    api,
+    method,
+    reqData,
+    reqParams,
+    reqBefore,
+    reqAfter,
+    cancelToken,
+    hooks
+  }) => {
+    if (!api) return {};
+    const loading = vue.ref(false);
+    let cancelRequest;
+    let apiFn;
+    if (typeof api === "string") {
+      const config = {
+        url: api,
+        method
+      };
+      if (cancelToken) {
+        config.cancelRequest = (cancel) => {
+          cancelRequest = cancel;
+        };
+      }
+      apiFn = (data = {}, params) => {
+        if (config.method === "get") {
+          config.params = data;
+        } else {
+          config.data = data;
+          config.params = params;
+        }
+        config.data = {
+          ...reqData,
+          ...config.data
+        };
+        config.params = {
+          ...reqParams,
+          ...config.params
+        };
+        if (data.$query) {
+          config.data[data.$query] = data.$searchValue;
+          delete data.$searchValue;
+        }
+        if (reqBefore) {
+          reqBefore(config);
+        }
+        return fetch(config);
+      };
+    } else {
+      apiFn = api;
+    }
+    const requestFn = async (data = {}) => {
+      if (loading.value && !cancelToken) return;
+      loading.value = true;
+      try {
+        cancelRequest && cancelRequest();
+        const res = await apiFn(data);
+        if (reqAfter) {
+          reqAfter(res);
+        }
+        if (hooks?.success) {
+          hooks.success(res.data);
+        }
+      } catch (error) {
+        if (hooks?.fail) {
+          hooks.fail(error);
+        }
+      } finally {
+        loading.value = false;
+      }
+    };
+    return {
+      loading,
+      requestFn
+    };
+  };
+
+  const useTable$1 = (props) => {
+    const elFormRef = vue.useTemplateRef("elFormRef");
+    const elTableRef = vue.useTemplateRef("elTableRef");
+    const customData = vue.ref([]);
+    const {
+      loading,
+      requestFn
+    } = useRequest({
+      api: props.api,
+      method: props.method,
+      reqData: props.reqData,
+      reqParams: props.reqParams,
+      reqBefore: props.reqBefore,
+      reqAfter: props.reqAfter,
+      cancelToken: true,
+      hooks: {
+        success(data) {
+          if (Array.isArray(data)) {
+            customData.value = data;
+          } else if (data && typeof data === "object") {
+            const rawData = data;
+            customData.value = rawData?.list || rawData?.data || [];
+          } else {
+            customData.value = [];
+          }
+          if (props.showPagination) {
+            pagination.total = (props.isFrontPage ? customData.value.length : data.total) || 0;
+          }
+        },
+        fail(error) {
+          console.error(error);
+        }
+      }
+    });
+    const search = (init = false, isPagination = false) => {
+      if (init) {
+        pagination.pageNo = 1;
+      }
+      if (isPagination && props.isFrontPage) {
+        const {
+          pageNo,
+          pageSize
+        } = pagination;
+        const data = customData.value.filter((item, index) => {
+          return index < pageNo * pageSize && index >= (pageNo - 1) * pageSize;
+        });
+        customData.value = data;
+      } else {
+        if (props.api) {
+          requestFn({
+            pageNo: pagination.pageNo,
+            pageSize: pagination.pageSize
+          });
+        } else if (props.data?.length) {
+          customData.value = props.data;
+        }
+      }
+    };
+    const {
+      pagination,
+      paginationProps
+    } = usePagination(props, search);
+    search(true);
+    const validate = () => {
+      return elFormRef.value.validate();
+    };
+    const resetFields = (props2) => {
+      return elFormRef.value.resetFields(props2);
+    };
+    const clearValidate = (props2) => {
+      return elFormRef.value.clearValidate(props2);
+    };
+    const formatActionButtons = (list, scope) => {
+      return list.map((item) => {
+        if (item.onClick) {
+          item.onClick = item.onClick.bind(null, scope);
+        }
+        return item;
+      });
+    };
+    return {
+      loading,
+      data: customData,
+      search,
+      pagination,
+      paginationProps,
+      validate,
+      resetFields,
+      clearValidate,
+      elFormRef,
+      elTableRef,
+      formatActionButtons
+    };
+  };
+  const usePagination = function(props, search) {
+    const pageSizes = [20, 50, 100, 200];
+    const pagination = vue.reactive({
+      total: 0,
+      pageNo: 1,
+      pageSize: pageSizes[0]
+    });
+    const paginationProps = vue.computed(() => {
+      const defaultPaginationProps = props.paginationProps || {};
+      const onSizeChange = defaultPaginationProps.onSizeChange;
+      const onCurrentChange = defaultPaginationProps.onCurrentChange;
+      return {
+        ...defaultPaginationProps,
+        pageSizes,
+        layout: "total, sizes, prev, pager, next, jumper",
+        onSizeChange: (value) => {
+          onSizeChange && onSizeChange(value);
+          search(true, true);
+        },
+        onCurrentChange: (value) => {
+          onCurrentChange && onCurrentChange(value);
+          search(false, true);
+        }
+      };
+    });
+    return {
+      pagination,
+      paginationProps
+    };
+  };
+  const useTableColumn = (props, tableData) => {
+    const columnProps = (column) => {
+      const attrs = {
+        align: column.align || props.align
+        // ...prepareEvents<TableEmits>(emit, tableEmits),
+      };
+      if (!column.renderHeader) {
+        let required = column.required;
+        if (typeof column.required === "function") {
+          required = column.required();
+        }
+        if (required) {
+          attrs["renderHeader"] = (data) => {
+            const {
+              column: column2
+            } = data;
+            return vue.createVNode("span", null, [vue.createVNode("span", {
+              "style": "color:var(--el-color-danger)"
+            }, [vue.createTextVNode(" * ")]), column2.label]);
+          };
+        }
+      }
+      if (column.headerRender) {
+        attrs.renderHeader = column.headerRender;
+      }
+      if (column.filter) {
+        const arr = tableData.value.map((item) => item[column.prop]);
+        attrs.filters = [...new Set(arr)].map((item) => {
+          return {
+            text: item,
+            value: item
+          };
+        });
+        attrs.filterMethod = (value, row) => {
+          return row[column.prop] === value;
+        };
+      }
+      return {
+        ...attrs,
+        ...prepareProps(column)
+      };
+    };
+    const columnList = vue.computed(() => {
+      return props.columns.filter((column) => {
+        if (props.linkProps.length) {
+          const linkColumn = props.linkProps.find((item) => item.prop === column.prop);
+          if (linkColumn) {
+            column.type = "EpButtons";
+            column.className = "table-column-link";
+            column.props = {
+              list: [linkColumn],
+              type: "text",
+              ...column.props
+            };
+          }
+        }
+        if ("show" in column) {
+          return typeof column.show === "function" ? column.show(column) : column.show;
+        } else if ("hide" in column) {
+          return typeof column.hide === "function" ? !column.hide(column) : !column.hide;
+        }
+        return true;
+      });
+    });
+    return {
+      columnProps,
+      columnList
+    };
+  };
+  const useTableFormItem = (props) => {
+    const formItemProps = (scope, item) => {
+      let required = item.required;
+      if (typeof required === "function") {
+        required = required();
+      }
+      if (item.cellRequired) {
+        required = item.cellRequired(scope);
+      }
+      let disabled = props.disabled;
+      if ("disabled" in item) {
+        if (typeof item.disabled === "function") {
+          disabled = item.disabled(scope);
+        } else {
+          disabled = item.disabled || false;
+        }
+      }
+      if (item.type === "EpSelect" && item.props) {
+        if ("options" in item.props && typeof item.props.options === "function") {
+          item.props.options = item.props.options(scope);
+        }
+        if ("disabledOption" in item.props && typeof item.props.disabledOption === "function") {
+          const disabledOption = item.props.disabledOption;
+          item.props.disabledOption = (...args) => disabledOption(...args, scope);
+        }
+      }
+      if (item.type === "EpButtons" && item.props) {
+        item.props.list.forEach((btnItem) => {
+          if (btnItem.prop) {
+            btnItem.name = scope.row[btnItem.prop];
+          }
+          if (btnItem.onClick) {
+            btnItem.onClick = btnItem.onClick.bind(null, scope);
+          }
+        });
+      }
+      for (const key in item) {
+        if (key.startsWith("on") && typeof item[key] === "function") {
+          const fn = item[key];
+          item[key] = (...args) => fn(...args, scope);
+        }
+      }
+      return {
+        ...prepareProps(item),
+        isShowLabel: false,
+        required,
+        hideRequiredAsterisk: "cellRequired" in item ? false : required,
+        prop: `table.${scope.$index}.${item.prop}`,
+        tableProp: item.prop,
+        // table里的表单需要绑定的prop
+        props: {
+          ...item.props,
+          disabled
+        }
+      };
+    };
+    return {
+      formItemProps
+    };
+  };
+
+  var _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+    ...{
+      name: "EpTable",
+      inheritAttrs: false
+    },
+    __name: "table",
+    props: tableProps,
+    emits: tableEmits,
+    setup(__props, {
+      expose: __expose,
+      emit: __emit
+    }) {
+      const bem = createNameSpace("table");
+      const props = __props;
+      const emit = __emit;
+      const slots = vue.computed(() => {
+        return Object.keys(vue.useSlots());
+      });
+      const customAttrs = vue.computed(() => {
+        return {
+          ...prepareProps(props, ["modelValue", ...expandTablePropsKeys]),
+          size: "small",
+          data: data.value,
+          ...prepareEvents(emit, tableEmitsKeys)
+        };
+      });
+      const {
+        pagination,
+        paginationProps,
+        data,
+        validate,
+        resetFields,
+        clearValidate,
+        loading,
+        search,
+        elFormRef,
+        elTableRef,
+        formatActionButtons
+      } = useTable$1(props);
+      const {
+        columnProps,
+        columnList
+      } = useTableColumn(props, data);
+      const {
+        formItemProps
+      } = useTableFormItem(props);
+      __expose({
+        elFormRef,
+        elTableRef,
+        validate,
+        resetFields,
+        clearValidate,
+        search
+      });
+      return (_ctx, _cache) => {
+        const _component_el_table_column = vue.resolveComponent("el-table-column");
+        const _component_EpButtons = vue.resolveComponent("EpButtons");
+        const _component_el_table = vue.resolveComponent("el-table");
+        const _component_el_form = vue.resolveComponent("el-form");
+        const _component_el_pagination = vue.resolveComponent("el-pagination");
+        const _directive_loading = vue.resolveDirective("loading");
+        return vue.openBlock(), vue.createElementBlock(
+          "div",
+          {
+            class: vue.normalizeClass(`${vue.unref(bem).b()} ${vue.unref(prepareClassNames)()}`),
+            style: vue.normalizeStyle({
+              ...vue.unref(prepareStyles)()
+            })
+          },
+          [vue.createVNode(_component_el_form, {
+            ref_key: "elFormRef",
+            ref: elFormRef,
+            model: {
+              table: vue.unref(data)
+            },
+            size: "small",
+            "hide-required-asterisk": "",
+            "scroll-to-error": "",
+            "scroll-into-view-options": {
+              inline: "center"
+            },
+            class: "ep-form"
+          }, {
+            default: vue.withCtx(() => [vue.withDirectives((vue.openBlock(), vue.createBlock(
+              _component_el_table,
+              vue.mergeProps({
+                ref_key: "elTableRef",
+                ref: elTableRef
+              }, customAttrs.value),
+              vue.createSlots({
+                default: vue.withCtx(() => [_ctx.showSelectionCol ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                  key: 0,
+                  type: "selection",
+                  width: "55",
+                  align: _ctx.align,
+                  selectable: _ctx.selectable,
+                  fixed: ""
+                }, null, 8, ["align", "selectable"])) : vue.createCommentVNode("v-if", true), _ctx.showIndexCol ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                  key: 1,
+                  type: "index",
+                  width: "56",
+                  align: _ctx.align,
+                  label: "\u5E8F\u53F7",
+                  fixed: "",
+                  index: _ctx.indexFormatter
+                }, null, 8, ["align", "index"])) : vue.createCommentVNode("v-if", true), _ctx.actionButtons.length ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                  key: 2,
+                  label: "\u64CD\u4F5C",
+                  align: _ctx.align,
+                  fixed: "",
+                  width: "200"
+                }, {
+                  default: vue.withCtx((scope) => [vue.createElementVNode(
+                    "span",
+                    {
+                      class: vue.normalizeClass(vue.unref(bem).e("action-buttons"))
+                    },
+                    [vue.createVNode(_component_EpButtons, {
+                      list: vue.unref(formatActionButtons)(_ctx.actionButtons, scope),
+                      type: "text"
+                    }, null, 8, ["list"])],
+                    2
+                    /* CLASS */
+                  )]),
+                  _: 1
+                  /* STABLE */
+                }, 8, ["align"])) : vue.createCommentVNode("v-if", true), (vue.openBlock(true), vue.createElementBlock(
+                  vue.Fragment,
+                  null,
+                  vue.renderList(vue.unref(columnList), (item, index) => {
+                    return vue.openBlock(), vue.createBlock(
+                      _component_el_table_column,
+                      vue.mergeProps({
+                        key: index
+                      }, {
+                        ref_for: true
+                      }, vue.unref(columnProps)(item)),
+                      {
+                        default: vue.withCtx((scope) => [item.type ? (vue.openBlock(), vue.createBlock(vue.unref(EpFormItem), vue.mergeProps({
+                          key: 0,
+                          "form-data": scope.row
+                        }, {
+                          ref_for: true
+                        }, vue.unref(formItemProps)(scope, item)), null, 16, ["form-data"])) : (vue.openBlock(), vue.createElementBlock(
+                          vue.Fragment,
+                          {
+                            key: 1
+                          },
+                          [vue.createTextVNode(
+                            vue.toDisplayString(scope.row[item.prop]),
+                            1
+                            /* TEXT */
+                          )],
+                          64
+                          /* STABLE_FRAGMENT */
+                        ))]),
+                        _: 2
+                        /* DYNAMIC */
+                      },
+                      1040
+                      /* FULL_PROPS, DYNAMIC_SLOTS */
+                    );
+                  }),
+                  128
+                  /* KEYED_FRAGMENT */
+                ))]),
+                _: 2
+                /* DYNAMIC */
+              }, [vue.renderList(slots.value, (name) => {
+                return {
+                  name,
+                  fn: vue.withCtx((scope) => [vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(scope)))])
+                };
+              })]),
+              1040
+              /* FULL_PROPS, DYNAMIC_SLOTS */
+            )), [[_directive_loading, vue.unref(loading)]])]),
+            _: 3
+            /* FORWARDED */
+          }, 8, ["model"]), _ctx.showPagination ? (vue.openBlock(), vue.createBlock(_component_el_pagination, vue.mergeProps({
+            key: 0,
+            "current-page": vue.unref(pagination).pageNo,
+            "onUpdate:currentPage": ($event) => vue.unref(pagination).pageNo = $event,
+            "page-size": vue.unref(pagination).pageSize,
+            "onUpdate:pageSize": ($event) => vue.unref(pagination).pageSize = $event,
+            total: vue.unref(pagination).total
+          }, vue.unref(paginationProps)), null, 16, ["current-page", "onUpdate:currentPage", "page-size", "onUpdate:pageSize", "total"])) : vue.createCommentVNode("v-if", true)],
+          6
+          /* CLASS, STYLE */
+        );
+      };
+    }
+  });
+
+  var Table = withInstall(_sfc_main$2);
+
+  console.log(formProps.formItemList);
+  const searchListPageProps = {
+    ...apiProps,
+    customColumnModule: Number,
+    // 自定义列模块
+    showOperationColumn: Boolean,
+    // 是否显示操作列
+    // 表单列表
+    formItemList: {
+      ...formProps.formItemList
+    },
+    // 左侧按钮
+    leftButtons: {
+      ...buttonsProps.list
+    },
+    // 表格列
+    columns: {
+      ...tableProps.columns
+    },
+    // 操作列
+    actionButtons: {
+      ...tableProps.actionButtons
+    },
+    // 链接列
+    linkProps: {
+      ...tableProps.linkProps
+    },
+    showSelectionCol: Boolean,
+    showIndexCol: {
+      type: Boolean,
+      default: true
+    },
+    add: Function,
+    // 新增
+    templateDownloadApi: String,
+    // 模板下载
+    importApi: String,
+    // 导入
+    exportApi: String,
+    // 导出
+    // 表格额外距离
+    offsetTop: {
+      type: Number,
+      default: 0
+    },
+    formData: {
+      type: Object,
+      default: () => ({})
+    },
+    tableProps: Object,
+    formProps: Object,
+    buttonsProps: Object
+  };
+
+  const useSearchListPage = (props) => {
+    const { calcTableHeight, tableProps, tableRef } = useTable(props);
+    const { formProps, validate, resetFields, formRef } = useForm(props, {
+      calcTableHeight
+    });
+    const { buttonsProps, searchButtons, search, reset } = useButtons(props, {
+      validate,
+      resetFields,
+      tableRef
+    });
+    return {
+      formProps,
+      tableProps,
+      buttonsProps,
+      searchButtons,
+      search,
+      reset,
+      tableRef,
+      formRef
+    };
+  };
+  const useTable = (props) => {
+    const instanceName = "tableRef";
+    const tableRef = vue.useTemplateRef(instanceName);
+    const tableHeight = vue.ref(window.innerHeight);
+    const tableProps = vue.computed(() => {
+      return {
+        ref: instanceName,
+        columns: props.columns,
+        showPagination: true,
+        height: tableHeight.value,
+        showIndexCol: props.showIndexCol,
+        showSelectionCol: props.showSelectionCol,
+        actionButtons: props.actionButtons,
+        linkProps: props.linkProps,
+        api: props.api,
+        reqData: props.formData,
+        ...props.tableProps
+      };
+    });
+    const calcTableHeight = () => {
+      const topHeight = document.getElementById("top").offsetHeight;
+      const middleHeight = document.getElementById("middle").offsetHeight;
+      let paginationHeight = 0;
+      if (tableProps.value.showPagination) {
+        paginationHeight = document.querySelector(".el-pagination").offsetHeight + 12;
+      }
+      const frameDistance = 40;
+      tableHeight.value = window.innerHeight - topHeight - middleHeight - paginationHeight - frameDistance - props.offsetTop;
+    };
+    vue.onMounted(calcTableHeight);
+    return {
+      tableRef,
+      tableProps,
+      calcTableHeight
+    };
+  };
+  const useForm = (props, { calcTableHeight }) => {
+    const instanceName = "formRef";
+    const formRef = vue.useTemplateRef(instanceName);
+    const formProps = vue.computed(() => {
+      return {
+        ref: instanceName,
+        formItemList: props.formItemList,
+        isShowFold: true,
+        modelValue: props.formData,
+        ...props.formProps,
+        onToggleStatus: () => {
+          setTimeout(() => {
+            calcTableHeight();
+          }, 0);
+        }
+      };
+    });
+    const validate = () => {
+      return formRef.value.validate();
+    };
+    const resetFields = (props2) => {
+      return formRef.value.resetFields(props2);
+    };
+    const clearValidate = (props2) => {
+      return formRef.value.clearValidate(props2);
+    };
+    return {
+      formProps,
+      formRef,
+      validate,
+      resetFields,
+      clearValidate
+    };
+  };
+  const useButtons = (props, { validate, resetFields, tableRef }) => {
+    const defaultButtons = [
+      {
+        name: "\u65B0\u589E",
+        prop: "add",
+        show: () => {
+          return !!props.add;
+        },
+        onClick: () => {
+          props.add?.();
+        }
+      },
+      {
+        name: "\u6A21\u7248\u4E0B\u8F7D",
+        prop: "templateDownload",
+        show: !!props.templateDownloadApi
+      },
+      {
+        name: "\u5BFC\u5165",
+        prop: "import",
+        show: !!props.importApi
+      },
+      {
+        name: "\u5BFC\u51FA",
+        prop: "export",
+        show: !!props.exportApi
+      }
+    ];
+    props.leftButtons?.forEach((item) => {
+      const defaultIndex = defaultButtons.findIndex(
+        (item1) => item1.prop === item.prop
+      );
+      if (defaultIndex !== -1) {
+        defaultButtons[defaultIndex] = {
+          ...defaultButtons[defaultIndex],
+          ...item
+        };
+      }
+    });
+    const list = defaultButtons.concat(props.leftButtons);
+    list.forEach((item) => {
+      if (item.onClick) {
+        const clickFn = item.onClick;
+        item.onClick = () => {
+          const rows = tableRef.value.elTableRef.getSelectionRows();
+          clickFn(rows);
+        };
+      }
+    });
+    const buttonsProps = vue.computed(() => {
+      return {
+        list,
+        ...props.buttonsProps
+      };
+    });
+    const search = async () => {
+      await validate();
+      tableRef.value.search(true);
+    };
+    const reset = async () => {
+      resetFields();
+      search();
+    };
+    const searchButtons = [
+      {
+        name: "\u641C\u7D22",
+        type: "primary",
+        onClick: search
+      },
+      {
+        name: "\u6E05\u7A7A",
+        onClick: reset
+      }
+    ];
+    return {
+      buttonsProps,
+      searchButtons,
+      search,
+      reset
+    };
+  };
+
+  var _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+    ...{ name: "EpSearchListPage" },
+    __name: "searchListPage",
+    props: searchListPageProps,
+    setup(__props, { expose: __expose }) {
+      const bem = createNameSpace("search-list-page");
+      const props = __props;
+      const {
+        formProps,
+        buttonsProps,
+        searchButtons,
+        search,
+        reset,
+        tableRef,
+        formRef,
+        tableProps
+      } = useSearchListPage(props);
+      __expose({
+        search,
+        reset,
+        tableRef,
+        formRef
+      });
+      return (_ctx, _cache) => {
+        const _component_EpButtons = vue.resolveComponent("EpButtons");
+        return vue.openBlock(), vue.createElementBlock(
+          "div",
+          {
+            class: vue.normalizeClass([vue.unref(bem).b(), vue.unref(prepareClassNames)()]),
+            style: vue.normalizeStyle({
+              ...vue.unref(prepareStyles)()
+            })
+          },
+          [
+            vue.createElementVNode("div", { id: "top" }, [
+              vue.createVNode(
+                vue.unref(Form),
+                vue.normalizeProps(vue.guardReactiveProps(vue.unref(formProps))),
+                null,
+                16
+                /* FULL_PROPS */
+              )
+            ]),
+            vue.createElementVNode("div", { id: "middle" }, [
+              vue.createElementVNode(
+                "div",
+                {
+                  class: vue.normalizeClass(vue.unref(bem).e("middle-left"))
+                },
+                [
+                  vue.createVNode(
+                    _component_EpButtons,
+                    vue.normalizeProps(vue.guardReactiveProps(vue.unref(buttonsProps))),
+                    null,
+                    16
+                    /* FULL_PROPS */
+                  )
+                ],
+                2
+                /* CLASS */
+              ),
+              vue.createElementVNode(
+                "div",
+                {
+                  class: vue.normalizeClass(vue.unref(bem).e("middle-right"))
+                },
+                [
+                  vue.createVNode(_component_EpButtons, { list: vue.unref(searchButtons) }, null, 8, ["list"])
+                ],
+                2
+                /* CLASS */
+              )
+            ]),
+            vue.renderSlot(_ctx.$slots, "tableBefore"),
+            vue.createVNode(
+              vue.unref(Table),
+              vue.normalizeProps(vue.guardReactiveProps(vue.unref(tableProps))),
+              null,
+              16
+              /* FULL_PROPS */
+            )
+          ],
+          6
+          /* CLASS, STYLE */
+        );
+      };
+    }
+  });
+
+  var SearchListPage = withInstall(_sfc_main$1);
+
+  const inheritSelectProps = {
+    ...elementPlus.selectProps,
+    clearable: {
+      ...elementPlus.selectProps.clearable,
+      default: true
+    }
+  };
+  const expandSelectProps = {
+    ...apiProps,
+    disabledOption: {
+      type: Function,
+      default: () => false
+    },
+    labelKey: {
+      type: String,
+      default: "label"
+    },
+    valueKey: {
+      type: String,
+      default: "value"
+    },
+    formatLabel: {
+      type: Function
+    },
+    // api模式生效
+    lazy: Boolean,
+    // option是否同时展示code label, 默认值展示label, 传string展示指定字段
+    codeInLabel: {
+      type: [String, Boolean]
+    }
+  };
+  const selectProps = {
+    ...inheritSelectProps,
+    ...expandSelectProps
+  };
+  const expandSelectPropsKeys = Object.keys(expandSelectProps);
+  const selectEmits = {
+    ...elementPlus.selectEmits,
+    change: (value, item) => true
+  };
+  const selectEmitsKeys = Object.keys(selectEmits);
+
+  function useSelect(props, emit) {
+    let hasLoaded = false;
+    const { loading, requestFn } = useRequest({
+      api: props.api,
+      method: props.method,
+      reqData: props.reqData,
+      reqParams: props.reqParams,
+      reqBefore: props.reqBefore,
+      reqAfter: props.reqAfter,
+      cancelToken: props.remote,
+      hooks: {
+        success(data) {
+          if (Array.isArray(data)) {
+            customOptions.value = data;
+          } else if (data && typeof data === "object") {
+            const rawData = data;
+            customOptions.value = rawData?.list || rawData?.data || [];
+          } else {
+            customOptions.value = [];
+          }
+          hasLoaded = true;
+        },
+        fail(error) {
+          console.error(error);
+        }
+      }
+    });
+    const customOptions = vue.ref([]);
+    const loadOptions = (value, desc) => {
+      if ((value || value === 0) && desc) {
+        customOptions.value = [
+          {
+            [props.labelKey]: desc,
+            [props.valueKey]: value
+          }
+        ];
+      }
+      if (props.api) {
+        if (!props.lazy && !props.remote) {
+          requestFn();
+        }
+      } else if (props.options?.length) {
+        customOptions.value = props.options;
+      }
+    };
+    const getSelectItem = (value) => {
+      if (Array.isArray(value)) {
+        if (!props.options) return [];
+        return props.options.filter((item) => {
+          return value.indexOf(item[props.valueKey]) > -1;
+        });
+      }
+      if (!props.options) return {};
+      return props.options.find((item) => {
+        return item[props.valueKey] === value;
+      }) || {};
+    };
+    const expandAttrs = {
+      loading: props.loading || loading?.value,
+      remoteMethod: (query) => {
+        if (!query) return;
+        requestFn({
+          $searchValue: query
+        });
+      },
+      onChange(value) {
+        emit("change", value, getSelectItem(value));
+      },
+      onVisibleChange(visible) {
+        if (props.api && props.lazy && visible && !hasLoaded && !props.remote) {
+          requestFn();
+        }
+        emit("visible-change", visible);
+      }
+    };
+    return {
+      customOptions,
+      loadOptions,
+      expandAttrs
+    };
+  }
+
+  var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+    ...{
+      name: "EpSelect",
+      inheritAttrs: false
+    },
+    __name: "select",
+    props: /* @__PURE__ */ vue.mergeModels(selectProps, {
+      "modelValue": { type: null },
+      "modelModifiers": {},
+      "desc": { type: String },
+      "descModifiers": {}
+    }),
+    emits: /* @__PURE__ */ vue.mergeModels(selectEmits, ["update:modelValue", "update:desc"]),
+    setup(__props, { emit: __emit }) {
+      const bem = createNameSpace("select");
+      const props = __props;
+      const emit = __emit;
+      const slots = vue.computed(() => {
+        return Object.keys(vue.useSlots());
+      });
+      const { customOptions, loadOptions, expandAttrs } = useSelect(props, emit);
+      const value = vue.useModel(__props, "modelValue");
+      const desc = vue.useModel(__props, "desc");
+      const customAttrs = vue.computed(() => {
+        return {
+          ...prepareProps(props, ["modelValue", "desc", ...expandSelectPropsKeys]),
+          ...prepareEvents(emit, selectEmitsKeys),
+          ...expandAttrs
+        };
+      });
+      loadOptions(value.value, desc.value);
+      return (_ctx, _cache) => {
+        const _component_el_option = vue.resolveComponent("el-option");
+        const _component_el_select = vue.resolveComponent("el-select");
+        return vue.openBlock(), vue.createBlock(_component_el_select, vue.mergeProps({
+          modelValue: value.value,
+          "onUpdate:modelValue": ($event) => value.value = $event,
+          class: `${vue.unref(bem).b()} ${vue.unref(prepareClassNames)()}`
+        }, customAttrs.value, {
+          style: {
+            ...vue.unref(prepareStyles)()
+          }
+        }), vue.createSlots({
+          default: vue.withCtx(() => [
+            (vue.openBlock(true), vue.createElementBlock(
+              vue.Fragment,
+              null,
+              vue.renderList(vue.unref(customOptions), (item) => {
+                return vue.openBlock(), vue.createBlock(_component_el_option, {
+                  key: item[_ctx.valueKey],
+                  class: vue.normalizeClass(vue.unref(bem).e("option")),
+                  label: item.formatLabel ? item.formatLabel(item) : _ctx.formatLabel ? _ctx.formatLabel(item) : item[_ctx.labelKey],
+                  value: item[_ctx.valueKey],
+                  disabled: _ctx.disabledOption(item)
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.renderSlot(_ctx.$slots, "option", { item }, () => [
+                      _ctx.codeInLabel || _ctx.codeInLabel === "" ? (vue.openBlock(), vue.createElementBlock(
+                        vue.Fragment,
+                        { key: 0 },
+                        [
+                          vue.createElementVNode(
+                            "span",
+                            { style: { "float": "left" } },
+                            vue.toDisplayString(item[_ctx.labelKey]),
+                            1
+                            /* TEXT */
+                          ),
+                          vue.createElementVNode(
+                            "span",
+                            { style: { "float": "right", "color": "var(--el-text-color-secondary)", "font-size": "13px" } },
+                            vue.toDisplayString(item[typeof _ctx.codeInLabel === "string" && _ctx.codeInLabel ? _ctx.codeInLabel : _ctx.valueKey]),
+                            1
+                            /* TEXT */
+                          )
+                        ],
+                        64
+                        /* STABLE_FRAGMENT */
+                      )) : vue.createCommentVNode("v-if", true)
+                    ])
+                  ]),
+                  _: 2
+                  /* DYNAMIC */
+                }, 1032, ["class", "label", "value", "disabled"]);
+              }),
+              128
+              /* KEYED_FRAGMENT */
+            ))
+          ]),
+          _: 2
+          /* DYNAMIC */
+        }, [
+          vue.renderList(slots.value, (name) => {
+            return {
+              name,
+              fn: vue.withCtx((scope) => [
+                vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(scope)))
+              ])
+            };
+          })
+        ]), 1040, ["modelValue", "onUpdate:modelValue", "class", "style"]);
+      };
+    }
+  });
+
+  var Select = withInstall(_sfc_main);
+
+  var components = [Buttons, Form, Input, SearchListPage, Select, Table];
+
+  var version = "0.0.1";
+
+  const install = (app, options) => {
+    components.forEach((c) => app.use(c));
+  };
+  const plugin = {
+    install,
+    version
+  };
+
+  exports.EpFormItem = EpFormItem;
+  exports.buttonsProps = buttonsProps;
+  exports.default = plugin;
+  exports.expandFormItemPropsKeys = expandFormItemPropsKeys;
+  exports.expandFormPropsKeys = expandFormPropsKeys;
+  exports.expandSelectPropsKeys = expandSelectPropsKeys;
+  exports.expandTablePropsKeys = expandTablePropsKeys;
+  exports.formEmits = formEmits;
+  exports.formEmitsKeys = formEmitsKeys;
+  exports.formItemProps = formItemProps;
+  exports.formProps = formProps;
+  exports.inheritSelectProps = inheritSelectProps;
+  exports.inputEmits = inputEmits;
+  exports.inputEmitsKeys = inputEmitsKeys;
+  exports.inputProps = inputProps;
+  exports.install = install;
+  exports.searchListPageProps = searchListPageProps;
+  exports.selectEmits = selectEmits;
+  exports.selectEmitsKeys = selectEmitsKeys;
+  exports.selectProps = selectProps;
+  exports.tableEmits = tableEmits;
+  exports.tableEmitsKeys = tableEmitsKeys;
+  exports.tableProps = tableProps;
+  exports.useRequest = useRequest;
+  exports.vPermission = vPermisson;
+  exports.vRepeatClick = vRepeatClick;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));