el-plus 0.0.2

package/dist/index.full.mjs

@@ -0,0 +1,2185 @@
+/*! ElPlus v0.0.2 */
+
+import { useAttrs, defineComponent, computed, createVNode, Fragment, withDirectives, resolveComponent, mergeProps, resolveDirective, useTemplateRef, ref, createTextVNode, h, mergeModels, useModel, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createCommentVNode, withCtx, renderSlot, renderList, createBlock, vShow, toDisplayString, reactive, useSlots, watch, onMounted, createSlots, normalizeProps, guardReactiveProps, createElementVNode } from 'vue';
+import { buttonProps, ElMessage, ElLoading, ElMessageBox, formProps as formProps$1, formEmits as formEmits$1, formItemProps as formItemProps$1, inputProps as inputProps$1, inputEmits as inputEmits$1, ElTable, selectProps as selectProps$1, selectEmits as selectEmits$1 } from 'element-plus';
+import axios from 'axios';
+import 'element-plus/es/components/message/style/css';
+import 'element-plus/es/components/loading/style/css';
+import elTableProps from 'element-plus/es/components/table/src/table/defaults';
+
+const buttonsProps = {
+  ...buttonProps,
+  disabled: {
+    type: [Boolean, Function]
+  },
+  list: {
+    type: Array,
+    default: () => []
+  },
+  size: {
+    ...buttonProps.size,
+    default: "small"
+  },
+  type: {
+    ...buttonProps.type,
+    default: "default"
+  },
+  test: {
+    type: String,
+    required: true
+  },
+  test1: {
+    type: String,
+    required: true,
+    default: "test1"
+  }
+};
+
+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 useAttrs().class || "";
+};
+const prepareStyles = () => {
+  return 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 = 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(() => {
+        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) {
+      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 = /* @__PURE__ */ defineComponent({
+  name: "EpButtons",
+  directives: {
+    [vRepeatClick.name]: vRepeatClick,
+    [vPermisson.name]: vPermisson
+  },
+  inheritAttrs: false,
+  props: buttonsProps,
+  setup(props, {
+    emit
+  }) {
+    const {
+      list,
+      ...buttonProps
+    } = props;
+    const customList = 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 ElMessageBox.confirm(confirmText, "Warning", {
+          confirmButtonText: "\u786E\u5B9A",
+          cancelButtonText: "\u53D6\u6D88",
+          type: "warning"
+        });
+      }
+      item.onClick();
+    };
+    return () => createVNode(Fragment, null, [customList.value.map((item) => {
+      const permissionArr = item.permission?.split(":") || [];
+      return withDirectives(createVNode(resolveComponent("el-button"), 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
+      }), [[resolveDirective("repeat-click"), typeof item.onClick === "function" ? {
+        handler: () => clickFn(item),
+        immediate: true
+      } : () => clickFn(item)], [resolveDirective("permission"), {
+        arg: permissionArr[0],
+        value: permissionArr[1]
+      }]]);
+    })]);
+  }
+});
+
+function withInstall(comp) {
+  comp.install = (app) => {
+    app.component(comp.name, comp);
+  };
+  return comp;
+}
+
+const EpButtons = withInstall(Buttons);
+
+const expandFormProps = {
+  // 表单列表
+  formItemList: {
+    type: Array,
+    default: () => []
+  },
+  // 是否显示折叠
+  isShowFold: Boolean,
+  // 最大显示的表单数
+  showFieldCount: {
+    type: Number,
+    default: 8
+  },
+  // 每行的列数
+  col: {
+    type: Number,
+    default: 4
+  }
+};
+const formProps = {
+  ...formProps$1,
+  ...expandFormProps,
+  size: {
+    ...formProps$1.size,
+    default: "small"
+  },
+  // 标签的长度
+  labelWidth: {
+    ...formProps$1.labelWidth,
+    default: 120
+  },
+  scrollIntoViewOptions: {
+    ...formProps$1.scrollIntoViewOptions,
+    default: () => {
+      return { inline: "center" };
+    }
+  }
+};
+const expandFormPropsKeys = Object.keys(expandFormProps);
+const formEmits = {
+  ...formEmits$1,
+  toggleStatus: (status) => true
+  // 折叠状态切换时触发
+};
+const formEmitsKeys = Object.keys(formEmits);
+
+const useCollapse = ({ isShowFold, showFieldCount, filterFormItemList }, emit) => {
+  const open = ref(false);
+  const toggleStatus = () => {
+    open.value = !open.value;
+    emit("toggleStatus", open.value);
+  };
+  const isShowFoldBtn = 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 = useTemplateRef("elFormRef");
+  const filterFormItemList = 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 = 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 ? h(resolveComponent(type), {
+        modelValue: formData[prop],
+        "onUpdate:modelValue": (value) => {
+          formData[prop] = value;
+        },
+        ...renderProps,
+        ...events
+      }, renderScopedSlots) : formData[prop];
+    },
+    label: () => {
+      return createVNode(resolveComponent("el-tooltip"), {
+        "placement": "top",
+        "effect": "light",
+        "content": label,
+        "disabled": !props.isShowLabel
+      }, {
+        default: () => [createVNode("span", null, [!props.hideRequiredAsterisk && required ? createVNode("span", {
+          "style": "color: var(--el-color-danger);"
+        }, [createTextVNode("*")]) : null, props.isShowLabel ? 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 = {
+  ...formItemProps$1,
+  ...expandFormItemProps
+};
+const expandFormItemPropsKeys = Object.keys(expandFormItemProps);
+
+const bem = createNameSpace("form-item");
+var EpFormItem = /* @__PURE__ */ defineComponent({
+  name: "EpFormItem",
+  inheritAttrs: false,
+  props: formItemProps,
+  setup(props, {
+    emit
+  }) {
+    const attrs = useAttrs();
+    const {
+      scopedSlots
+    } = useFormItemSlots(props);
+    const {
+      rules
+    } = useFormItemRules(props);
+    const {
+      props: childProps,
+      ...formItemProps2
+    } = props;
+    return () => {
+      return createVNode(resolveComponent("el-form-item"), mergeProps({
+        "class": [bem.b(), prepareClassNames()],
+        "style": prepareStyles()
+      }, {
+        ...prepareProps(formItemProps2, [...expandFormItemPropsKeys]),
+        rules,
+        "label-width": attrs["form-label-width"]
+      }), scopedSlots);
+    };
+  }
+});
+
+var _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "EpForm",
+    inheritAttrs: false
+  },
+  __name: "form",
+  props: /* @__PURE__ */ mergeModels(formProps, {
+    "modelValue": { type: Object, ...{
+      default: () => reactive({})
+    } },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(formEmits, ["update:modelValue"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const bem = createNameSpace("form");
+    const props = __props;
+    const emit = __emit;
+    const customAttrs = computed(() => {
+      return {
+        ...prepareProps(props, ["modelValue", "model", ...expandFormPropsKeys]),
+        hideRequiredAsterisk: true,
+        // 隐藏必填星号, 使用自己的*
+        scrollToError: true,
+        ...prepareEvents(emit, formEmitsKeys)
+      };
+    });
+    const formData = 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 = resolveComponent("el-col");
+      const _component_el_row = resolveComponent("el-row");
+      const _component_el_form = resolveComponent("el-form");
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass([
+            unref(bem).b(),
+            unref(prepareClassNames)(),
+            unref(bem).is("open", unref(open)),
+            unref(bem).is("fold", unref(isShowFoldBtn))
+          ]),
+          style: normalizeStyle({
+            ...unref(prepareStyles)()
+          })
+        },
+        [
+          createVNode(_component_el_form, mergeProps({
+            ref_key: "elFormRef",
+            ref: elFormRef,
+            model: formData.value
+          }, customAttrs.value), {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default", {}, () => [
+                createVNode(_component_el_row, null, {
+                  default: withCtx(() => [
+                    (openBlock(true), createElementBlock(
+                      Fragment,
+                      null,
+                      renderList(unref(filterFormItemList), (item, index) => {
+                        return withDirectives((openBlock(), createBlock(_component_el_col, {
+                          key: item.prop || index,
+                          class: normalizeClass(unref(bem).e("col")),
+                          span: item.col || 24 / _ctx.col
+                        }, {
+                          default: withCtx(() => [
+                            createVNode(unref(EpFormItem), 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"])), [
+                          [vShow, unref(isShowFormItem)(index)]
+                        ]);
+                      }),
+                      128
+                      /* KEYED_FRAGMENT */
+                    ))
+                  ]),
+                  _: 1
+                  /* STABLE */
+                })
+              ])
+            ]),
+            _: 3
+            /* FORWARDED */
+          }, 16, ["model"]),
+          unref(isShowFoldBtn) ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: normalizeClass(unref(bem).e("fold")),
+            onClick: unref(toggleStatus)
+          }, toDisplayString(unref(open) ? "\u6536\u8D77" : "\u66F4\u591A"), 11, ["onClick"])) : createCommentVNode("v-if", true)
+        ],
+        6
+        /* CLASS, STYLE */
+      );
+    };
+  }
+});
+
+const EpForm = withInstall(_sfc_main$4);
+
+const inputProps = {
+  ...inputProps$1,
+  max: Number,
+  min: Number,
+  radix: Number,
+  nonzero: Boolean,
+  placeholder: {
+    type: String,
+    default: "\u8BF7\u8F93\u5165"
+  },
+  thousand: {
+    type: Boolean,
+    default: true
+  },
+  clearable: {
+    ...inputProps$1.clearable,
+    default: true
+  }
+};
+const inputEmits = {
+  ...inputEmits$1
+};
+const inputEmitsKeys = Object.keys(inputEmits);
+
+var _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "EpInput",
+    inheritAttrs: false
+  },
+  __name: "input",
+  props: /* @__PURE__ */ mergeModels(inputProps, {
+    "modelValue": { type: null },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(inputEmits, ["update:modelValue"]),
+  setup(__props, { emit: __emit }) {
+    const bem = createNameSpace("input");
+    const props = __props;
+    const emit = __emit;
+    const slots = computed(() => {
+      return Object.keys(useSlots());
+    });
+    let isBluring = false;
+    let isFocusing = false;
+    const customAttrs = 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 = useModel(__props, "modelValue");
+    const inputRef = ref();
+    const toThousand = (val) => {
+      if (props.thousand) {
+        return val ? window.hx.thousand(val) : val;
+      }
+      return val;
+    };
+    watch(
+      () => value.value,
+      (val) => {
+        if (props.type === "number") {
+          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 = resolveComponent("el-input");
+      return openBlock(), createBlock(_component_el_input, mergeProps({
+        ref_key: "inputRef",
+        ref: inputRef,
+        modelValue: value.value,
+        "onUpdate:modelValue": ($event) => value.value = $event,
+        class: `${unref(bem).b()} ${unref(prepareClassNames)()}`,
+        style: {
+          ...unref(prepareStyles)()
+        }
+      }, customAttrs.value, {
+        type: _ctx.type === "number" ? "text" : _ctx.type
+      }), createSlots({
+        _: 2
+        /* DYNAMIC */
+      }, [
+        renderList(slots.value, (name) => {
+          return {
+            name,
+            fn: withCtx((scope) => [
+              renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(scope)))
+            ])
+          };
+        })
+      ]), 1040, ["modelValue", "onUpdate:modelValue", "class", "style", "type"]);
+    };
+  }
+});
+
+const EpInput = 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 = ElTable.emits;
+const tableEmitsKeys = tableEmits;
+
+const useRequest = ({
+  api,
+  method,
+  reqData,
+  reqParams,
+  reqBefore,
+  reqAfter,
+  cancelToken,
+  hooks
+}) => {
+  if (!api) return {};
+  const loading = 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 = useTemplateRef("elFormRef");
+  const elTableRef = useTemplateRef("elTableRef");
+  const customData = 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 = reactive({
+    total: 0,
+    pageNo: 1,
+    pageSize: pageSizes[0]
+  });
+  const paginationProps = 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 createVNode("span", null, [createVNode("span", {
+            "style": "color:var(--el-color-danger)"
+          }, [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 = 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__ */ 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 = computed(() => {
+      return Object.keys(useSlots());
+    });
+    const customAttrs = 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 = resolveComponent("el-table-column");
+      const _component_EpButtons = resolveComponent("EpButtons");
+      const _component_el_table = resolveComponent("el-table");
+      const _component_el_form = resolveComponent("el-form");
+      const _component_el_pagination = resolveComponent("el-pagination");
+      const _directive_loading = resolveDirective("loading");
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass(`${unref(bem).b()} ${unref(prepareClassNames)()}`),
+          style: normalizeStyle({
+            ...unref(prepareStyles)()
+          })
+        },
+        [createVNode(_component_el_form, {
+          ref_key: "elFormRef",
+          ref: elFormRef,
+          model: {
+            table: unref(data)
+          },
+          size: "small",
+          "hide-required-asterisk": "",
+          "scroll-to-error": "",
+          "scroll-into-view-options": {
+            inline: "center"
+          },
+          class: "ep-form"
+        }, {
+          default: withCtx(() => [withDirectives((openBlock(), createBlock(
+            _component_el_table,
+            mergeProps({
+              ref_key: "elTableRef",
+              ref: elTableRef
+            }, customAttrs.value),
+            createSlots({
+              default: withCtx(() => [_ctx.showSelectionCol ? (openBlock(), createBlock(_component_el_table_column, {
+                key: 0,
+                type: "selection",
+                width: "55",
+                align: _ctx.align,
+                selectable: _ctx.selectable,
+                fixed: ""
+              }, null, 8, ["align", "selectable"])) : createCommentVNode("v-if", true), _ctx.showIndexCol ? (openBlock(), 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"])) : createCommentVNode("v-if", true), _ctx.actionButtons.length ? (openBlock(), createBlock(_component_el_table_column, {
+                key: 2,
+                label: "\u64CD\u4F5C",
+                align: _ctx.align,
+                fixed: "",
+                width: "200"
+              }, {
+                default: withCtx((scope) => [createElementVNode(
+                  "span",
+                  {
+                    class: normalizeClass(unref(bem).e("action-buttons"))
+                  },
+                  [createVNode(_component_EpButtons, {
+                    list: unref(formatActionButtons)(_ctx.actionButtons, scope),
+                    type: "text"
+                  }, null, 8, ["list"])],
+                  2
+                  /* CLASS */
+                )]),
+                _: 1
+                /* STABLE */
+              }, 8, ["align"])) : createCommentVNode("v-if", true), (openBlock(true), createElementBlock(
+                Fragment,
+                null,
+                renderList(unref(columnList), (item, index) => {
+                  return openBlock(), createBlock(
+                    _component_el_table_column,
+                    mergeProps({
+                      key: index
+                    }, {
+                      ref_for: true
+                    }, unref(columnProps)(item)),
+                    {
+                      default: withCtx((scope) => [item.type ? (openBlock(), createBlock(unref(EpFormItem), mergeProps({
+                        key: 0,
+                        "form-data": scope.row
+                      }, {
+                        ref_for: true
+                      }, unref(formItemProps)(scope, item)), null, 16, ["form-data"])) : (openBlock(), createElementBlock(
+                        Fragment,
+                        {
+                          key: 1
+                        },
+                        [createTextVNode(
+                          toDisplayString(scope.row[item.prop]),
+                          1
+                          /* TEXT */
+                        )],
+                        64
+                        /* STABLE_FRAGMENT */
+                      ))]),
+                      _: 2
+                      /* DYNAMIC */
+                    },
+                    1040
+                    /* FULL_PROPS, DYNAMIC_SLOTS */
+                  );
+                }),
+                128
+                /* KEYED_FRAGMENT */
+              ))]),
+              _: 2
+              /* DYNAMIC */
+            }, [renderList(slots.value, (name) => {
+              return {
+                name,
+                fn: withCtx((scope) => [renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(scope)))])
+              };
+            })]),
+            1040
+            /* FULL_PROPS, DYNAMIC_SLOTS */
+          )), [[_directive_loading, unref(loading)]])]),
+          _: 3
+          /* FORWARDED */
+        }, 8, ["model"]), _ctx.showPagination ? (openBlock(), createBlock(_component_el_pagination, mergeProps({
+          key: 0,
+          "current-page": unref(pagination).pageNo,
+          "onUpdate:currentPage": ($event) => unref(pagination).pageNo = $event,
+          "page-size": unref(pagination).pageSize,
+          "onUpdate:pageSize": ($event) => unref(pagination).pageSize = $event,
+          total: unref(pagination).total
+        }, unref(paginationProps)), null, 16, ["current-page", "onUpdate:currentPage", "page-size", "onUpdate:pageSize", "total"])) : createCommentVNode("v-if", true)],
+        6
+        /* CLASS, STYLE */
+      );
+    };
+  }
+});
+
+const EpTable = 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 = useTemplateRef(instanceName);
+  const tableHeight = ref(window.innerHeight);
+  const tableProps = 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;
+  };
+  onMounted(calcTableHeight);
+  return {
+    tableRef,
+    tableProps,
+    calcTableHeight
+  };
+};
+const useForm = (props, { calcTableHeight }) => {
+  const instanceName = "formRef";
+  const formRef = useTemplateRef(instanceName);
+  const formProps = 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 = 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__ */ 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 = resolveComponent("EpButtons");
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass([unref(bem).b(), unref(prepareClassNames)()]),
+          style: normalizeStyle({
+            ...unref(prepareStyles)()
+          })
+        },
+        [
+          createElementVNode("div", { id: "top" }, [
+            createVNode(
+              unref(EpForm),
+              normalizeProps(guardReactiveProps(unref(formProps))),
+              null,
+              16
+              /* FULL_PROPS */
+            )
+          ]),
+          createElementVNode("div", { id: "middle" }, [
+            createElementVNode(
+              "div",
+              {
+                class: normalizeClass(unref(bem).e("middle-left"))
+              },
+              [
+                createVNode(
+                  _component_EpButtons,
+                  normalizeProps(guardReactiveProps(unref(buttonsProps))),
+                  null,
+                  16
+                  /* FULL_PROPS */
+                )
+              ],
+              2
+              /* CLASS */
+            ),
+            createElementVNode(
+              "div",
+              {
+                class: normalizeClass(unref(bem).e("middle-right"))
+              },
+              [
+                createVNode(_component_EpButtons, { list: unref(searchButtons) }, null, 8, ["list"])
+              ],
+              2
+              /* CLASS */
+            )
+          ]),
+          renderSlot(_ctx.$slots, "tableBefore"),
+          createVNode(
+            unref(EpTable),
+            normalizeProps(guardReactiveProps(unref(tableProps))),
+            null,
+            16
+            /* FULL_PROPS */
+          )
+        ],
+        6
+        /* CLASS, STYLE */
+      );
+    };
+  }
+});
+
+const EpSearchListPage = withInstall(_sfc_main$1);
+
+const inheritSelectProps = {
+  ...selectProps$1,
+  clearable: {
+    ...selectProps$1.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 = {
+  ...selectEmits$1,
+  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 = 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__ */ defineComponent({
+  ...{
+    name: "EpSelect",
+    inheritAttrs: false
+  },
+  __name: "select",
+  props: /* @__PURE__ */ mergeModels(selectProps, {
+    "modelValue": { type: null },
+    "modelModifiers": {},
+    "desc": { type: String },
+    "descModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(selectEmits, ["update:modelValue", "update:desc"]),
+  setup(__props, { emit: __emit }) {
+    const bem = createNameSpace("select");
+    const props = __props;
+    const emit = __emit;
+    const slots = computed(() => {
+      return Object.keys(useSlots());
+    });
+    const { customOptions, loadOptions, expandAttrs } = useSelect(props, emit);
+    const value = useModel(__props, "modelValue");
+    const desc = useModel(__props, "desc");
+    const customAttrs = computed(() => {
+      return {
+        ...prepareProps(props, ["modelValue", "desc", ...expandSelectPropsKeys]),
+        ...prepareEvents(emit, selectEmitsKeys),
+        ...expandAttrs
+      };
+    });
+    loadOptions(value.value, desc.value);
+    return (_ctx, _cache) => {
+      const _component_el_option = resolveComponent("el-option");
+      const _component_el_select = resolveComponent("el-select");
+      return openBlock(), createBlock(_component_el_select, mergeProps({
+        modelValue: value.value,
+        "onUpdate:modelValue": ($event) => value.value = $event,
+        class: `${unref(bem).b()} ${unref(prepareClassNames)()}`
+      }, customAttrs.value, {
+        style: {
+          ...unref(prepareStyles)()
+        }
+      }), createSlots({
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(
+            Fragment,
+            null,
+            renderList(unref(customOptions), (item) => {
+              return openBlock(), createBlock(_component_el_option, {
+                key: item[_ctx.valueKey],
+                class: normalizeClass(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: withCtx(() => [
+                  renderSlot(_ctx.$slots, "option", { item }, () => [
+                    _ctx.codeInLabel || _ctx.codeInLabel === "" ? (openBlock(), createElementBlock(
+                      Fragment,
+                      { key: 0 },
+                      [
+                        createElementVNode(
+                          "span",
+                          { style: { "float": "left" } },
+                          toDisplayString(item[_ctx.labelKey]),
+                          1
+                          /* TEXT */
+                        ),
+                        createElementVNode(
+                          "span",
+                          { style: { "float": "right", "color": "var(--el-text-color-secondary)", "font-size": "13px" } },
+                          toDisplayString(item[typeof _ctx.codeInLabel === "string" && _ctx.codeInLabel ? _ctx.codeInLabel : _ctx.valueKey]),
+                          1
+                          /* TEXT */
+                        )
+                      ],
+                      64
+                      /* STABLE_FRAGMENT */
+                    )) : createCommentVNode("v-if", true)
+                  ])
+                ]),
+                _: 2
+                /* DYNAMIC */
+              }, 1032, ["class", "label", "value", "disabled"]);
+            }),
+            128
+            /* KEYED_FRAGMENT */
+          ))
+        ]),
+        _: 2
+        /* DYNAMIC */
+      }, [
+        renderList(slots.value, (name) => {
+          return {
+            name,
+            fn: withCtx((scope) => [
+              renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(scope)))
+            ])
+          };
+        })
+      ]), 1040, ["modelValue", "onUpdate:modelValue", "class", "style"]);
+    };
+  }
+});
+
+const EpSelect = withInstall(_sfc_main);
+
+var components = [EpButtons, EpForm, EpInput, EpSearchListPage, EpSelect, EpTable];
+
+var version = "0.0.2";
+
+const install = (app, options) => {
+  components.forEach((c) => app.use(c));
+};
+const plugin = {
+  install,
+  version
+};
+
+export { EpButtons, EpForm, EpFormItem, EpInput, EpSearchListPage, EpSelect, EpTable, buttonsProps, plugin as default, expandFormItemPropsKeys, expandFormPropsKeys, expandSelectPropsKeys, expandTablePropsKeys, formEmits, formEmitsKeys, formItemProps, formProps, inheritSelectProps, inputEmits, inputEmitsKeys, inputProps, install, searchListPageProps, selectEmits, selectEmitsKeys, selectProps, tableEmits, tableEmitsKeys, tableProps, useRequest, vPermisson as vPermission, vRepeatClick };