@wfrog/vc-ui 1.0.0

package/dist/es/components/backbottom/backbottom.mjs

@@ -0,0 +1,172 @@
+import { defineComponent, useCssVars, useTemplateRef, ref, computed, onMounted, onBeforeUnmount, createBlock, openBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, renderSlot, createVNode, unref, vShow, Teleport, mergeProps } from 'vue';
+import '../../chunk/E_WRn0OP.mjs';
+import { CaretBottom } from '@element-plus/icons-vue';
+import { E as ElIcon } from '../../chunk/DMHNh_tw.mjs';
+import { _ as _export_sfc } from '../../chunk/pcqpp-6-.mjs';
+
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "child",
+  props: {
+    target: {},
+    right: { default: 40 },
+    bottom: { default: 40 },
+    visibilityHeight: { default: 200 },
+    parent: { type: Boolean }
+  },
+  emits: ["inited"],
+  setup(__props, { emit: __emit }) {
+    useCssVars((_ctx) => ({
+      "v10480682": `${-_ctx.right}px`,
+      "v003052db": `${_ctx.bottom}px`
+    }));
+    const props = __props;
+    const emits = __emit;
+    const backbottomRef = useTemplateRef("backbottomRef");
+    const myTarget = ref();
+    const diffHeight = ref(0);
+    const scrollHeight = ref(0);
+    const clientHeight = ref(0);
+    const hasVerticalScrollbar = computed(() => scrollHeight.value > clientHeight.value);
+    const visible = computed(() => hasVerticalScrollbar.value && diffHeight.value > props.visibilityHeight);
+    const teleportTarget = ref();
+    const needTeleport = ref(false);
+    function updateHeightData() {
+      scrollHeight.value = myTarget.value.scrollHeight;
+      clientHeight.value = myTarget.value.clientHeight;
+      const scrollTop = myTarget.value.scrollTop;
+      diffHeight.value = scrollHeight.value - clientHeight.value - scrollTop;
+    }
+    function scrollToBottom() {
+      myTarget.value?.scrollTo({ top: myTarget.value.scrollHeight, behavior: "smooth" });
+    }
+    function getTarget() {
+      let eleTarget;
+      if (props.parent) {
+        eleTarget = backbottomRef.value?.parentElement;
+        let container = eleTarget;
+        let elScrollTarget = null;
+        do {
+          if (container && container.classList.contains("el-scrollbar__wrap")) {
+            needTeleport.value = true;
+            elScrollTarget = container;
+          }
+          container = container?.parentElement;
+        } while (!elScrollTarget && container);
+        if (elScrollTarget) {
+          eleTarget = elScrollTarget;
+        }
+        return eleTarget;
+      }
+      if (props.target) {
+        needTeleport.value = true;
+        if (typeof props.target === "string") {
+          eleTarget = document.querySelector(props.target);
+        } else {
+          eleTarget = props.target;
+        }
+        return eleTarget;
+      }
+      return document.documentElement;
+    }
+    onMounted(() => {
+      myTarget.value = getTarget();
+      if (needTeleport.value) {
+        teleportTarget.value = myTarget.value;
+      }
+      if (myTarget.value === document.documentElement) {
+        teleportTarget.value = document.body;
+        document.addEventListener("scroll", updateHeightData);
+      } else {
+        myTarget.value.addEventListener("scroll", updateHeightData);
+      }
+      updateHeightData();
+      emits("inited", teleportTarget.value);
+    });
+    onBeforeUnmount(() => {
+      if (myTarget.value === document.documentElement) {
+        window.document.removeEventListener("scroll", updateHeightData);
+      } else {
+        myTarget.value.removeEventListener("scroll", updateHeightData);
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_ElIcon = ElIcon;
+      return openBlock(), createBlock(Transition, { name: "el-fade-in" }, {
+        default: withCtx(() => [
+          withDirectives(createElementVNode("div", {
+            ref_key: "backbottomRef",
+            ref: backbottomRef,
+            class: normalizeClass(_ctx.$style.wrapper)
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.$style.container)
+            }, [
+              createElementVNode("div", {
+                class: normalizeClass(_ctx.$style.body),
+                onClick: scrollToBottom
+              }, [
+                renderSlot(_ctx.$slots, "default", {}, () => [
+                  createVNode(_component_ElIcon, {
+                    class: normalizeClass(_ctx.$style.icon)
+                  }, {
+                    default: withCtx(() => [
+                      createVNode(unref(CaretBottom))
+                    ]),
+                    _: 1
+                  }, 8, ["class"])
+                ])
+              ], 2)
+            ], 2)
+          ], 2), [
+            [vShow, unref(visible)]
+          ])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+
+/* unplugin-vue-components disabled */const wrapper = "_wrapper_12g77_1";
+const container = "_container_12g77_11";
+const body = "_body_12g77_15";
+const icon = "_icon_12g77_34";
+const style0 = {
+	wrapper: wrapper,
+	container: container,
+	body: body,
+	icon: icon
+};
+
+const cssModules = {
+  "$style": style0
+};
+const Child = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__cssModules", cssModules]]);
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "backbottom",
+  props: {
+    target: {},
+    right: { default: 40 },
+    bottom: { default: 40 },
+    visibilityHeight: { default: 200 },
+    parent: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const teleportTarget = ref();
+    function handleInited(val) {
+      teleportTarget.value = val;
+    }
+    return (_ctx, _cache) => {
+      return unref(teleportTarget) ? (openBlock(), createBlock(Teleport, {
+        key: 0,
+        to: unref(teleportTarget)
+      }, [
+        createVNode(Child, mergeProps(props, { onInited: handleInited }), null, 16)
+      ], 8, ["to"])) : (openBlock(), createBlock(Child, mergeProps({ key: 1 }, props, { onInited: handleInited }), null, 16));
+    };
+  }
+});
+
+export { _sfc_main as _ };

package/dist/es/components/backbottom/backbottom.vue.d.ts

@@ -0,0 +1,7 @@
+import { IBackBottomProps } from './backbottom';
+declare const _default: import('vue').DefineComponent<IBackBottomProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IBackBottomProps> & Readonly<{}>, {
+    right: number;
+    bottom: number;
+    visibilityHeight: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/es/components/backbottom/components/child.vue.d.ts

@@ -0,0 +1,30 @@
+import { IBackBottomProps } from '../backbottom';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        backbottomRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<IBackBottomProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    inited: (target?: HTMLElement | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<IBackBottomProps> & Readonly<{
+    onInited?: ((target?: HTMLElement | undefined) => any) | undefined;
+}>, {
+    right: number;
+    bottom: number;
+    visibilityHeight: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    backbottomRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/backbottom/index.d.ts

@@ -0,0 +1,4 @@
+import { SFCWithInstall } from '../../utils/typescript';
+import { default as Component } from './backbottom.vue';
+export declare const VcBackbottom: SFCWithInstall<typeof Component>;
+export default VcBackbottom;

package/dist/es/components/backbottom/index.mjs

@@ -0,0 +1,6 @@
+import { w as withInstall } from '../../chunk/ClZGuAIb.mjs';
+import { _ as _sfc_main } from './backbottom.mjs';
+
+const VcBackbottom = withInstall(_sfc_main);
+
+export { VcBackbottom, VcBackbottom as default };

package/dist/es/components/button/button.d.ts

@@ -0,0 +1,18 @@
+import { ButtonType } from 'element-plus/es/components/button/src/button';
+export interface IIconOption {
+    name: string;
+    type?: IGlobal.IconType;
+    position?: 'left' | 'right';
+}
+export interface IButtonProps {
+    icon?: IIconOption;
+    time?: number;
+    type?: ButtonType;
+    confirm?: {
+        type?: 'popconfirm' | 'messagebox' | 'none';
+        title?: string;
+        confirmButtonText?: string;
+        cancelButtonText?: string;
+        msg?: string;
+    };
+}

package/dist/es/components/button/button.mjs

@@ -0,0 +1,313 @@
+import './index.css'
+import { c as buildProps, u as useNamespace } from '../../chunk/E_WRn0OP.mjs';
+import { f as useTooltipTriggerProps, u as useTooltipContentProps, a as ElTooltip } from '../../chunk/DqUIKX7f.mjs';
+/* empty css                    */
+import { b as buttonTypes, E as ElButton } from '../../chunk/VCrtRnxt.mjs';
+import { defineComponent, ref, computed, unref, createBlock, openBlock, mergeProps, withCtx, renderSlot, createCommentVNode, createElementVNode, normalizeClass, createTextVNode, normalizeStyle, resolveDynamicComponent, toDisplayString, createVNode, createElementBlock } from 'vue';
+import { ElMessageBox } from 'element-plus';
+import { i as injectConfig } from '../config-provider/config-provider2.mjs';
+import { C as Component$1 } from '../icon/icon.mjs';
+import { a as useThrottleFn } from '../../chunk/qY9OvNHY.mjs';
+import { E as ElIcon } from '../../chunk/DMHNh_tw.mjs';
+import { QuestionFilled } from '@element-plus/icons-vue';
+import { i as iconPropType } from '../icon/icon2.mjs';
+import { _ as _export_sfc, w as withInstall } from '../../chunk/D389hx_T.mjs';
+import { u as useLocale } from '../../chunk/aibQ9WSZ.mjs';
+import { a as addUnit } from '../../chunk/D5259bwd.mjs';
+import { _ as _export_sfc$1 } from '../../chunk/pcqpp-6-.mjs';
+
+const popconfirmProps = buildProps({
+  title: String,
+  confirmButtonText: String,
+  cancelButtonText: String,
+  confirmButtonType: {
+    type: String,
+    values: buttonTypes,
+    default: "primary"
+  },
+  cancelButtonType: {
+    type: String,
+    values: buttonTypes,
+    default: "text"
+  },
+  icon: {
+    type: iconPropType,
+    default: () => QuestionFilled
+  },
+  iconColor: {
+    type: String,
+    default: "#f90"
+  },
+  hideIcon: Boolean,
+  hideAfter: {
+    type: Number,
+    default: 200
+  },
+  effect: {
+    ...useTooltipContentProps.effect,
+    default: "light"
+  },
+  teleported: useTooltipContentProps.teleported,
+  persistent: useTooltipContentProps.persistent,
+  width: {
+    type: [String, Number],
+    default: 150
+  },
+  virtualTriggering: useTooltipTriggerProps.virtualTriggering,
+  virtualRef: useTooltipTriggerProps.virtualRef
+});
+const popconfirmEmits = {
+  confirm: (e) => e instanceof MouseEvent,
+  cancel: (e) => e instanceof MouseEvent
+};
+
+const __default__ = defineComponent({
+  name: "ElPopconfirm"
+});
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: popconfirmProps,
+  emits: popconfirmEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { t } = useLocale();
+    const ns = useNamespace("popconfirm");
+    const tooltipRef = ref();
+    const rootRef = ref();
+    const popperRef = computed(() => {
+      var _a;
+      return (_a = unref(tooltipRef)) == null ? void 0 : _a.popperRef;
+    });
+    const showPopper = () => {
+      var _a, _b;
+      (_b = (_a = rootRef.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
+    };
+    const hidePopper = () => {
+      var _a, _b;
+      (_b = (_a = tooltipRef.value) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
+    };
+    const style = computed(() => {
+      return {
+        width: addUnit(props.width)
+      };
+    });
+    const confirm = (e) => {
+      emit("confirm", e);
+      hidePopper();
+    };
+    const cancel = (e) => {
+      emit("cancel", e);
+      hidePopper();
+    };
+    const finalConfirmButtonText = computed(() => props.confirmButtonText || t("el.popconfirm.confirmButtonText"));
+    const finalCancelButtonText = computed(() => props.cancelButtonText || t("el.popconfirm.cancelButtonText"));
+    expose({
+      popperRef,
+      hide: hidePopper
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ElTooltip), mergeProps({
+        ref_key: "tooltipRef",
+        ref: tooltipRef,
+        trigger: "click",
+        effect: _ctx.effect
+      }, _ctx.$attrs, {
+        "virtual-triggering": _ctx.virtualTriggering,
+        "virtual-ref": _ctx.virtualRef,
+        "popper-class": `${unref(ns).namespace.value}-popover`,
+        "popper-style": unref(style),
+        teleported: _ctx.teleported,
+        "fallback-placements": ["bottom", "top", "right", "left"],
+        "hide-after": _ctx.hideAfter,
+        persistent: _ctx.persistent,
+        loop: "",
+        onShow: showPopper
+      }), {
+        content: withCtx(() => [
+          createElementVNode("div", {
+            ref_key: "rootRef",
+            ref: rootRef,
+            tabindex: "-1",
+            class: normalizeClass(unref(ns).b())
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(unref(ns).e("main"))
+            }, [
+              !_ctx.hideIcon && _ctx.icon ? (openBlock(), createBlock(unref(ElIcon), {
+                key: 0,
+                class: normalizeClass(unref(ns).e("icon")),
+                style: normalizeStyle({ color: _ctx.iconColor })
+              }, {
+                default: withCtx(() => [
+                  (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon)))
+                ]),
+                _: 1
+              }, 8, ["class", "style"])) : createCommentVNode("v-if", true),
+              createTextVNode(" " + toDisplayString(_ctx.title), 1)
+            ], 2),
+            createElementVNode("div", {
+              class: normalizeClass(unref(ns).e("action"))
+            }, [
+              renderSlot(_ctx.$slots, "actions", {
+                confirm,
+                cancel
+              }, () => [
+                createVNode(unref(ElButton), {
+                  size: "small",
+                  type: _ctx.cancelButtonType === "text" ? "" : _ctx.cancelButtonType,
+                  text: _ctx.cancelButtonType === "text",
+                  onClick: cancel
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref(finalCancelButtonText)), 1)
+                  ]),
+                  _: 1
+                }, 8, ["type", "text"]),
+                createVNode(unref(ElButton), {
+                  size: "small",
+                  type: _ctx.confirmButtonType === "text" ? "" : _ctx.confirmButtonType,
+                  text: _ctx.confirmButtonType === "text",
+                  onClick: confirm
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref(finalConfirmButtonText)), 1)
+                  ]),
+                  _: 1
+                }, 8, ["type", "text"])
+              ])
+            ], 2)
+          ], 2)
+        ]),
+        default: withCtx(() => [
+          _ctx.$slots.reference ? renderSlot(_ctx.$slots, "reference", { key: 0 }) : createCommentVNode("v-if", true)
+        ]),
+        _: 3
+      }, 16, ["effect", "virtual-triggering", "virtual-ref", "popper-class", "popper-style", "teleported", "hide-after", "persistent"]);
+    };
+  }
+});
+var Popconfirm = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__file", "popconfirm.vue"]]);
+
+const ElPopconfirm = withInstall(Popconfirm);
+
+const _hoisted_1 = { key: 1 };
+const _hoisted_2 = { key: 1 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "button",
+  props: {
+    icon: {},
+    time: { default: 800 },
+    type: { default: "" },
+    confirm: { default: void 0 }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { button: buttonConfig } = injectConfig();
+    const defaultConfirmInfo = { title: "提示", confirmButtonText: "确定", cancelButtonText: "取消", msg: "请确认您的操作" };
+    const myConfirm = computed(() => buttonConfig?.confirm?.type !== void 0 ? buttonConfig?.confirm?.type : props.confirm?.type !== void 0 ? props.confirm.type : ["danger", "warning"].includes(props.type) ? "messagebox" : void 0);
+    const { name, type: iconType = "el", position = "left" } = props.icon || {};
+    const { msg, title, confirmButtonText, cancelButtonText } = { ...defaultConfirmInfo, ...buttonConfig?.confirm, ...props.confirm };
+    async function handleComfirm() {
+      try {
+        const result = await ElMessageBox.confirm(msg, title, { confirmButtonText, cancelButtonText, type: "warning", dangerouslyUseHTMLString: true });
+        return result;
+      } catch {
+        return false;
+      }
+    }
+    const handleClick = useThrottleFn(async (e) => {
+      if (myConfirm.value === "messagebox") {
+        const result = await handleComfirm();
+        result && emits("click", e);
+        return;
+      }
+      if (myConfirm.value === "popconfirm") {
+        return;
+      }
+      emits("click", e);
+    }, props.time);
+    const handleConfirm = useThrottleFn(async (e) => {
+      emits("click", e);
+    }, props.time);
+    return (_ctx, _cache) => {
+      const _component_ElButton = ElButton;
+      const _component_ElPopconfirm = ElPopconfirm;
+      return unref(myConfirm) === "popconfirm" ? (openBlock(), createBlock(_component_ElPopconfirm, {
+        key: 0,
+        title: unref(msg),
+        "confirm-button-text": unref(confirmButtonText),
+        "cancel-button-text": unref(cancelButtonText),
+        "popper-class": `${_ctx.$style.popper} el-popover`,
+        onConfirm: unref(handleConfirm)
+      }, {
+        reference: withCtx(() => [
+          createVNode(_component_ElButton, mergeProps(_ctx.$attrs, {
+            type: __props.type,
+            class: _ctx.$style.button,
+            onClick: unref(handleClick)
+          }), {
+            default: withCtx(() => [
+              unref(position) === "left" && unref(name) ? (openBlock(), createBlock(Component$1, {
+                key: 0,
+                type: unref(iconType),
+                name: unref(name)
+              }, null, 8, ["type", "name"])) : createCommentVNode("", true),
+              _ctx.$slots.default ? (openBlock(), createElementBlock("span", _hoisted_1, [
+                renderSlot(_ctx.$slots, "default")
+              ])) : createCommentVNode("", true),
+              unref(position) === "right" && unref(name) ? (openBlock(), createBlock(Component$1, {
+                key: 2,
+                type: unref(iconType),
+                name: unref(name)
+              }, null, 8, ["type", "name"])) : createCommentVNode("", true)
+            ]),
+            _: 3
+          }, 16, ["type", "class", "onClick"])
+        ]),
+        _: 3
+      }, 8, ["title", "confirm-button-text", "cancel-button-text", "popper-class", "onConfirm"])) : (openBlock(), createBlock(_component_ElButton, mergeProps({ key: 1 }, _ctx.$attrs, {
+        type: __props.type,
+        class: _ctx.$style.button,
+        onClick: unref(handleClick)
+      }), {
+        default: withCtx(() => [
+          unref(position) === "left" && unref(name) ? (openBlock(), createBlock(Component$1, {
+            key: 0,
+            type: unref(iconType),
+            name: unref(name)
+          }, null, 8, ["type", "name"])) : createCommentVNode("", true),
+          _ctx.$slots.default ? (openBlock(), createElementBlock("span", _hoisted_2, [
+            renderSlot(_ctx.$slots, "default")
+          ])) : createCommentVNode("", true),
+          unref(position) === "right" && unref(name) ? (openBlock(), createBlock(Component$1, {
+            key: 2,
+            type: unref(iconType),
+            name: unref(name)
+          }, null, 8, ["type", "name"])) : createCommentVNode("", true)
+        ]),
+        _: 3
+      }, 16, ["type", "class", "onClick"]));
+    };
+  }
+});
+
+/* unplugin-vue-components disabled */const button = "_button_1dzv7_1";
+const popper = "_popper_1dzv7_5";
+const style0 = {
+	button: button,
+	popper: popper
+};
+
+const cssModules = {
+  "$style": style0
+};
+const Component = /* @__PURE__ */ _export_sfc$1(_sfc_main, [["__cssModules", cssModules]]);
+
+const __vite_glob_0_2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  default: Component
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { Component as C, __vite_glob_0_2 as _ };

package/dist/es/components/button/button.vue.d.ts

@@ -0,0 +1,33 @@
+import { IButtonProps } from './button';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<IButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<IButtonProps> & Readonly<{
+    onClick?: ((event: Event) => any) | undefined;
+}>, {
+    type: import('element-plus').ButtonType;
+    time: number;
+    confirm: {
+        type?: "popconfirm" | "messagebox" | "none";
+        title?: string;
+        confirmButtonText?: string;
+        cancelButtonText?: string;
+        msg?: string;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/button/index.css

@@ -0,0 +1,9 @@
+/* source: src/components/button/button.vue */
+.el-popconfirm{outline:none}.el-popconfirm__main{align-items:center;display:flex}.el-popconfirm__icon{margin-right:5px}.el-popconfirm__action{margin-top:8px;text-align:right}._button_1dzv7_1 > span > * + * {
+  margin-left: 0.5em;
+}
+._popper_1dzv7_5 {
+  width: auto !important;
+  min-width: 150px;
+  max-width: 300px;
+}

package/dist/es/components/button/index.d.ts

@@ -0,0 +1,4 @@
+import { SFCWithInstall } from '../../utils/typescript';
+import { default as Component } from './button.vue';
+export declare const VcButton: SFCWithInstall<typeof Component>;
+export default VcButton;

package/dist/es/components/button/index.mjs

@@ -0,0 +1,6 @@
+import { w as withInstall } from '../../chunk/ClZGuAIb.mjs';
+import { C as Component } from './button.mjs';
+
+const VcButton = withInstall(Component);
+
+export { VcButton, VcButton as default };

package/dist/es/components/cdn-tag.vue.d.ts

@@ -0,0 +1,5 @@
+interface IPropType {
+    name: string;
+}
+declare const _default: import('vue').DefineComponent<IPropType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IPropType> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/es/components/chat-container/chat-container.d.ts

@@ -0,0 +1,9 @@
+export interface IChatContainerProps {
+    stopHeight?: number;
+    keepBottom?: boolean;
+    backbottomClassName?: string;
+    backbottomProps?: {
+        visibilityHeight?: number;
+        bottom?: number;
+    };
+}