@ganwei-web/gw-base-components-plus 1.0.0

package/element-plus-adapter/dist/ElementPlusAdapter.cjs

@@ -0,0 +1,902 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const elementPlus = require("element-plus");
+function useExpose(proxyElement) {
+  const expose = new Proxy({}, {
+    get(target, key) {
+      var _a;
+      return (_a = proxyElement.value) == null ? void 0 : _a[key];
+    },
+    has(target, key) {
+      return key in proxyElement.value;
+    }
+  });
+  return expose;
+}
+const _sfc_main$n = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    const loading = vue.ref(false);
+    const handleClick = async (evt) => {
+      if (!attrs.onClick)
+        return;
+      const res = attrs.onClick(evt);
+      if (res instanceof Promise) {
+        loading.value = true;
+        res.finally(() => {
+          loading.value = false;
+        });
+      }
+      return res;
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), vue.mergeProps({ type: "primary", loading: loading.value, ...vue.unref(attrs), onClick: handleClick }, {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$k = "";
+const _sfc_main$m = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCascader), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$j = "";
+const _sfc_main$l = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCheckbox), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$i = "";
+const _sfc_main$k = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCollapse), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }, vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1536);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$h = "";
+const _sfc_main$j = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    defaultTime: {},
+    valueFormat: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const props = __props;
+    const attrs = vue.useAttrs();
+    const defaultTime = parseDate(props.defaultTime);
+    const valueFormat = props.valueFormat || "YYYY-MM-DD HH:mm:ss";
+    function parseDate(defaultTime2) {
+      if (!defaultTime2) {
+        return void 0;
+      }
+      if (Array.isArray(defaultTime2)) {
+        if (defaultTime2[0] && defaultTime2[1]) {
+          return [parseDate(defaultTime2[0]), parseDate(defaultTime2[1])];
+        }
+        return [new Date(2e3, 1, 1, 0, 0, 0), new Date(2e3, 1, 1, 23, 59, 59)];
+      }
+      if (defaultTime2 instanceof Date) {
+        return defaultTime2;
+      }
+      const [h = 0, m = 0, s = 0] = defaultTime2.split(":");
+      return new Date(2e3, 1, 1, Number(h), Number(m), Number(s));
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDatePicker), vue.mergeProps(vue.unref(attrs), {
+        "default-time": vue.unref(defaultTime),
+        "value-format": vue.unref(valueFormat),
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040, ["default-time", "value-format"]);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$g = "";
+const _sfc_main$i = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDialog), vue.mergeProps(_ctx.$attrs, {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$f = "";
+const UI_AUTOMATION_TOKEN = `data-testid`;
+function useDataTestId() {
+  const attrs = vue.useAttrs();
+  if (attrs[UI_AUTOMATION_TOKEN] === void 0 || attrs[UI_AUTOMATION_TOKEN] === null || typeof attrs[UI_AUTOMATION_TOKEN] !== "string") {
+    console.warn(`${UI_AUTOMATION_TOKEN} is required to UI Automation`);
+  }
+}
+const _sfc_main$h = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDrawer), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$e = "";
+const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDropdown), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$d = "";
+const _sfc_main$f = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElForm), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$c = "";
+/*! Element Plus Icons Vue v2.3.1 */
+var picture_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.defineComponent({
+  name: "Picture",
+  __name: "picture",
+  setup(__props) {
+    return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 1024 1024"
+    }, [
+      vue.createElementVNode("path", {
+        fill: "currentColor",
+        d: "M160 160v704h704V160zm-32-64h768a32 32 0 0 1 32 32v768a32 32 0 0 1-32 32H128a32 32 0 0 1-32-32V128a32 32 0 0 1 32-32"
+      }),
+      vue.createElementVNode("path", {
+        fill: "currentColor",
+        d: "M384 288q64 0 64 64t-64 64q-64 0-64-64t64-64M185.408 876.992l-50.816-38.912L350.72 556.032a96 96 0 0 1 134.592-17.856l1.856 1.472 122.88 99.136a32 32 0 0 0 44.992-4.864l216-269.888 49.92 39.936-215.808 269.824-.256.32a96 96 0 0 1-135.04 14.464l-122.88-99.072-.64-.512a32 32 0 0 0-44.8 5.952z"
+      })
+    ]));
+  }
+});
+var picture_default = picture_vue_vue_type_script_setup_true_lang_default;
+const _hoisted_1 = { class: "error-slot" };
+const _sfc_main$e = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    src: { default: "" },
+    request: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const props = __props;
+    const _src = vue.ref("");
+    vue.watch(() => props.src, async (newVal) => {
+      if (!newVal) {
+        return;
+      }
+      if (newVal.indexOf("/") > -1) {
+        _src.value = newVal;
+        return;
+      } else {
+        if (!props.request) {
+          _src.value = newVal;
+          return;
+        }
+        props.request({ id: props.src }).then((res) => {
+          const blob = res.data;
+          try {
+            URL.revokeObjectURL(_src.value);
+          } catch (e) {
+          }
+          _src.value = URL.createObjectURL(blob);
+        });
+      }
+    }, {
+      immediate: true
+    });
+    return (_ctx, _cache) => {
+      const _component_el_icon = vue.resolveComponent("el-icon");
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElImage), {
+        fit: "contain",
+        lazy: "",
+        src: _src.value,
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }, vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        }),
+        !_ctx.$slots.error ? {
+          name: "error",
+          fn: vue.withCtx(() => [
+            vue.createElementVNode("div", _hoisted_1, [
+              vue.createVNode(_component_el_icon, null, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(picture_default))
+                ]),
+                _: 1
+              })
+            ])
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1032, ["src"]);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$b = "";
+const _sfc_main$d = /* @__PURE__ */ vue.defineComponent({
+  __name: "ElInput",
+  props: {
+    "modelValue": {
+      default: ""
+    },
+    "modelModifiers": {}
+  },
+  emits: /* @__PURE__ */ vue.mergeModels(["change"], ["update:modelValue"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const input = vue.ref();
+    const expose = useExpose(input);
+    __expose(expose);
+    const model = vue.useModel(__props, "modelValue");
+    let preChangeVal = "";
+    const emits = __emit;
+    function changeHandler(val) {
+      if (preChangeVal === val)
+        return;
+      preChangeVal = val;
+      emits("change", val);
+    }
+    function inputHandler(val) {
+      if (model.value !== "" && val.trim() === "") {
+        changeHandler("");
+      }
+      model.value = val.trim();
+    }
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElInput), vue.mergeProps({
+        ref_key: "input",
+        ref: input,
+        modelValue: model.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => model.value = $event)
+      }, vue.unref(attrs), {
+        onInput: inputHandler,
+        onChange: changeHandler
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040, ["modelValue"]);
+    };
+  }
+});
+const ElInput_vue_vue_type_style_index_0_lang = "";
+const index$2 = "";
+const vLoading = {
+  mounted(el, binding, vnode, prevVnode) {
+    var _a, _b;
+    const vueInstance = vnode.ctx.proxy;
+    el.setAttribute(`element-loading-text`, (vueInstance == null ? void 0 : vueInstance.$t("login.tips.loading")) + "...");
+    el.setAttribute(`element-loading-spinner`, " ");
+    el.setAttribute(`element-loading-background`, "customLoading");
+    (_b = (_a = elementPlus.vLoading).mounted) == null ? void 0 : _b.call(_a, el, binding, vnode, prevVnode);
+  },
+  updated(el, binding, vnode, prevVnode) {
+    var _a, _b;
+    (_b = (_a = elementPlus.vLoading).updated) == null ? void 0 : _b.call(_a, el, binding, vnode, prevVnode);
+  },
+  unmounted(el, binding, vnode, prevVnode) {
+    var _a, _b;
+    (_b = (_a = elementPlus.vLoading).unmounted) == null ? void 0 : _b.call(_a, el, binding, vnode, prevVnode);
+  }
+};
+const _sfc_main$c = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElMenu), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$a = "";
+const index$1 = "";
+const index = "";
+const install = elementPlus.ElNotification.install;
+const defaultOption = {
+  duration: 2e3
+};
+const ElNotification = elementPlus.ElNotification;
+const notificationTypes = [
+  "success",
+  "info",
+  "warning",
+  "error"
+];
+notificationTypes.forEach((type) => {
+  ElNotification[type] = (options) => {
+    if (typeof options === "string") {
+      return elementPlus.ElNotification[type](options);
+    }
+    if (vue.isVNode(options)) {
+      return elementPlus.ElNotification[type](options);
+    }
+    let data = {
+      ...defaultOption,
+      ...options,
+      customClass: type,
+      type
+    };
+    return ElNotification(data);
+  };
+});
+ElNotification.install = (app) => {
+  install == null ? void 0 : install(app);
+  app.config.globalProperties.$notify = ElNotification;
+};
+const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const defaultAttrs = {
+      pageSizes: [20, 50, 100],
+      layout: "sizes,prev, pager, next,total"
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElPagination), vue.mergeProps({ ...defaultAttrs, ...vue.unref(attrs) }, {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$9 = "";
+const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElPopover), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }, vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1536);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$8 = "";
+const _sfc_main$9 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElRadio), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$7 = "";
+const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    round: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElRadioGroup), vue.mergeProps(vue.unref(attrs), {
+        class: { round: __props.round },
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040, ["class"]);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$6 = "";
+const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElSelect), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$5 = "";
+const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElSwitch), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$4 = "";
+const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    formatter: {
+      type: Function,
+      default: null
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    function formatter_wrapper(row, column, cellValue, index2) {
+      if (props.formatter) {
+        return props.formatter(row, column, cellValue, index2);
+      }
+      return cellValue || "-";
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTableColumn), { formatter: formatter_wrapper }, vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.normalizeProps(vue.guardReactiveProps(slotProps)))
+            ])
+          };
+        })
+      ]), 1024);
+    };
+  }
+});
+function useResizeTable() {
+  const instance = vue.getCurrentInstance();
+  const height = vue.ref();
+  let el = null;
+  vue.onMounted(() => {
+    resizeTable();
+    window.addEventListener("resize", resizeTable);
+  });
+  vue.onBeforeUnmount(() => {
+    window.removeEventListener("resize", resizeTable);
+  });
+  function getPxNumber(value) {
+    if (value.endsWith("px")) {
+      return Number(value.slice(0, -2));
+    }
+    return 0;
+  }
+  function getElementHeight(el2) {
+    const stylesheet = getComputedStyle(el2);
+    return el2.clientHeight || getPxNumber(stylesheet.height);
+  }
+  function resizeTable() {
+    var _a, _b;
+    el = (_b = (_a = instance == null ? void 0 : instance.proxy) == null ? void 0 : _a.$el) == null ? void 0 : _b.parentElement;
+    if (el) {
+      const stylesheet = getComputedStyle(el);
+      height.value = getElementHeight(el) - getPxNumber(stylesheet.paddingTop) - getPxNumber(stylesheet.paddingBottom);
+    }
+  }
+  return height;
+}
+const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    height: {
+      type: Number,
+      default: null
+    }
+  },
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const tableHeight = useResizeTable();
+    useDataTestId();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTable), {
+        height: vue.unref(tableHeight),
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }, vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.normalizeProps(vue.guardReactiveProps(slotProps)))
+            ])
+          };
+        })
+      ]), 1032, ["height"]);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$3 = "";
+const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    const attrs = vue.useAttrs();
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTimePicker), vue.mergeProps(vue.unref(attrs), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }), vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTransfer), {
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }, null, 512);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$2 = "";
+const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const tree = vue.ref();
+    const expose = useExpose(tree);
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTree), {
+        ref_key: "tree",
+        ref: tree
+      }, vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1536);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang$1 = "";
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  setup(__props, { expose: __expose }) {
+    const proxyElement = vue.ref();
+    const expose = useExpose(proxyElement);
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElUpload), {
+        class: "upload_wrapper",
+        ref_key: "proxyElement",
+        ref: proxyElement
+      }, vue.createSlots({ _: 2 }, [
+        vue.renderList(_ctx.$slots, (value, key) => {
+          return {
+            name: key,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, key, vue.mergeProps(slotProps, { key }))
+            ])
+          };
+        })
+      ]), 1536);
+    };
+  }
+});
+const index_vue_vue_type_style_index_0_lang = "";
+const Adapter = {
+  ElInput: _sfc_main$d,
+  ElDropdown: _sfc_main$g,
+  ElMenu: _sfc_main$c,
+  ElRadioGroup: _sfc_main$8,
+  ElTable: _sfc_main$4,
+  ElTableColumn: _sfc_main$5,
+  ElSelect: _sfc_main$7,
+  ElPagination: _sfc_main$b,
+  ElButton: _sfc_main$n,
+  ElForm: _sfc_main$f,
+  ElCascader: _sfc_main$m,
+  ElRadio: _sfc_main$9,
+  ElCheckbox: _sfc_main$l,
+  ElDatePicker: _sfc_main$j,
+  ElTimePicker: _sfc_main$3,
+  ElDialog: _sfc_main$i,
+  ElSwitch: _sfc_main$6,
+  ElDrawer: _sfc_main$h,
+  ElPopover: _sfc_main$a,
+  ElTransfer: _sfc_main$2,
+  ElCollapse: _sfc_main$k,
+  ElImage: _sfc_main$e,
+  ElUpload: _sfc_main,
+  ElTree: _sfc_main$1
+};
+function adapterInstall(app) {
+  for (const [key, component] of Object.entries(Adapter)) {
+    app.component(key, component);
+  }
+  adapterLoading(app);
+  app.use(elementPlus.ElMessageBox);
+  app.use(ElNotification);
+}
+function adapterLoading(app) {
+  app.directive("loading", vLoading);
+}
+exports.adapterInstall = adapterInstall;
+exports.adapterLoading = adapterLoading;
+exports.default = Adapter;
+//# sourceMappingURL=ElementPlusAdapter.cjs.map