@vunk/plus 1.11.1 → 1.11.3

package/components/agent-chat-provider/index.mjs

@@ -50,7 +50,7 @@ function useAgent(request) {
     request
   });
 }
-function initAgentChat(request, parser) {
+function initAgentChat(request, parser, formatSend) {
   const [agent] = useAgent(request);
   const chat = useXChat({
     agent: agent.value,
@@ -58,10 +58,8 @@ function initAgentChat(request, parser) {
     parser
   });
   const onRequest = (message) => {
-    chat.onRequest({
-      role: Role.User,
-      content: message
-    });
+    const userMessage = formatSend(message);
+    chat.onRequest(userMessage);
   };
   const items = computed(() => {
     return chat.parsedMessages.value.map((item) => {
@@ -100,6 +98,9 @@ var _sfc_main = defineComponent({
     },
     parser: {
       type: Function
+    },
+    formatSend: {
+      type: Function
     }
   },
   emits: {
@@ -176,9 +177,16 @@ var _sfc_main = defineComponent({
       ];
       return list;
     };
+    const formatSend = (message) => {
+      return {
+        role: Role.User,
+        content: message
+      };
+    };
     const agentChat = initAgentChat(
       props.request ?? request,
-      props.parser ?? parser
+      props.parser ?? parser,
+      props.formatSend ?? formatSend
     );
     emit("load", agentChat);
     return slots.default;

package/components/agent-chat-provider/src/index.vue.d.ts

@@ -7,6 +7,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     parser: {
         type: PropType<AnyFunc>;
     };
+    formatSend: {
+        type: PropType<AnyFunc>;
+    };
 }>, import("vue").Slot<any> | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     load: null;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -16,6 +19,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     parser: {
         type: PropType<AnyFunc>;
     };
+    formatSend: {
+        type: PropType<AnyFunc>;
+    };
 }>> & Readonly<{
     onLoad?: ((...args: any[]) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/components/agent-chat-provider/src/types.d.ts

@@ -1,8 +1,8 @@
 import type { __VkBubbleTemplates } from '@vunk/plus/components/bubble-templates';
+import type { BubbleProps } from '@vunk/plus/element/bubble';
 import type { MaybeArray, Media, NormalObject } from '@vunk/shared';
 import type { RequestFn, SSEOutput, useXChat, XAgent, XRequestParams } from 'ant-design-x-vue';
 import type { ComputedRef } from 'vue';
-import type { BubbleListItemProps } from 'vue-element-plus-x/types/components/BubbleList/types';
 import type { MessageView } from './MessageView';
 export type RequestParams<Message> = Omit<XRequestParams, 'message'> & {
     message: Message;
@@ -18,6 +18,7 @@ export interface AgentChatContext {
 }
 export type Request = RequestFn<AgentMessage, RequestParams<AgentMessage>, RequestOutput>;
 export type Parser = (message: Partial<AgentMessage>) => MaybeArray<BubbleMessage>;
+export type formatSend = (message: string) => AgentMessage;
 export type RequestOutput = AgentMessage & SSEOutput;
 /**
  * @description   useXAgent request onSuccess 发送的数据
@@ -30,7 +31,7 @@ export type AgentMessage = Partial<BubbleMessage> & {
 /**
  * @description useXChat parser 解析数据
  */
-export type BubbleMessage = Partial<BubbleListItemProps> & {
+export type BubbleMessage = Partial<BubbleProps> & {
     role: string;
     content: string;
     /**

package/components/agent-chat-provider/src/use.d.ts

@@ -1,6 +1,6 @@
 import type { SSEOutput } from 'ant-design-x-vue';
-import type { AgentChatContext, AgentMessage, Parser, Request, RequestParams } from './types';
+import type { AgentChatContext, AgentMessage, formatSend, Parser, Request, RequestParams } from './types';
 import { useXAgent } from 'ant-design-x-vue';
 export declare function useAgent(request: Request): ReturnType<typeof useXAgent<AgentMessage, RequestParams<AgentMessage>, AgentMessage & SSEOutput>>;
-export declare function initAgentChat(request: Request, parser: Parser): AgentChatContext;
+export declare function initAgentChat(request: Request, parser: Parser, formatSend: formatSend): AgentChatContext;
 export declare function useAgentChat(): AgentChatContext;

package/components/broadcasting-markdown/index.mjs

@@ -9,6 +9,138 @@ import { c as commonjsGlobal } from '../_commonjsHelpers.mjs';
 import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 import { Deferred } from '@vunk/shared/promise';
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/lib/_AsyncQueueEntry.ts
+var _AsyncQueueEntry = class _AsyncQueueEntry {
+  constructor(queue) {
+    __publicField(this, "promise");
+    __publicField(this, "resolve");
+    __publicField(this, "reject");
+    __publicField(this, "queue");
+    __publicField(this, "signal", null);
+    __publicField(this, "signalListener", null);
+    this.queue = queue;
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+  setSignal(signal) {
+    if (signal.aborted) return this;
+    this.signal = signal;
+    this.signalListener = () => {
+      const index = this.queue["promises"].indexOf(this);
+      if (index !== -1) this.queue["promises"].splice(index, 1);
+      this.reject(new Error("Request aborted manually"));
+    };
+    this.signal.addEventListener("abort", this.signalListener);
+    return this;
+  }
+  use() {
+    this.dispose();
+    this.resolve();
+    return this;
+  }
+  abort() {
+    this.dispose();
+    this.reject(new Error("Request aborted manually"));
+    return this;
+  }
+  dispose() {
+    if (this.signal) {
+      this.signal.removeEventListener("abort", this.signalListener);
+      this.signal = null;
+      this.signalListener = null;
+    }
+  }
+};
+__name(_AsyncQueueEntry, "AsyncQueueEntry");
+var AsyncQueueEntry = _AsyncQueueEntry;
+
+// src/lib/AsyncQueue.ts
+var _AsyncQueue = class _AsyncQueue {
+  constructor() {
+    /**
+     * The promises array
+     */
+    __publicField(this, "promises", []);
+  }
+  /**
+   * The amount of entries in the queue, including the head.
+   * @seealso {@link queued} for the queued count.
+   */
+  get remaining() {
+    return this.promises.length;
+  }
+  /**
+   * The amount of queued entries.
+   * @seealso {@link remaining} for the count with the head.
+   */
+  get queued() {
+    return this.remaining === 0 ? 0 : this.remaining - 1;
+  }
+  /**
+   * Waits for last promise and queues a new one
+   * @example
+   * ```typescript
+   * const queue = new AsyncQueue();
+   * async function request(url, options) {
+   *     await queue.wait({ signal: options.signal });
+   *     try {
+   *         const result = await fetch(url, options);
+   *         // Do some operations with 'result'
+   *     } finally {
+   *         // Remove first entry from the queue and resolve for the next entry
+   *         queue.shift();
+   *     }
+   * }
+   *
+   * request(someUrl1, someOptions1); // Will call fetch() immediately
+   * request(someUrl2, someOptions2); // Will call fetch() after the first finished
+   * request(someUrl3, someOptions3); // Will call fetch() after the second finished
+   * ```
+   */
+  wait(options) {
+    const entry = new AsyncQueueEntry(this);
+    if (this.promises.length === 0) {
+      this.promises.push(entry);
+      return Promise.resolve();
+    }
+    this.promises.push(entry);
+    if (options?.signal) entry.setSignal(options.signal);
+    return entry.promise;
+  }
+  /**
+   * Unlocks the head lock and transfers the next lock (if any) to the head.
+   */
+  shift() {
+    if (this.promises.length === 0) return;
+    if (this.promises.length === 1) {
+      this.promises.shift();
+      return;
+    }
+    this.promises.shift();
+    this.promises[0].use();
+  }
+  /**
+   * Aborts all the pending promises.
+   * @note To avoid race conditions, this does **not** unlock the head lock.
+   */
+  abortAll() {
+    if (this.queued === 0) return;
+    for (let i = 1; i < this.promises.length; ++i) {
+      this.promises[i].abort();
+    }
+    this.promises.length = 1;
+  }
+};
+__name(_AsyncQueue, "AsyncQueue");
+var AsyncQueue = _AsyncQueue;
+
 function markdownToPlainText(md) {
   return md.replace(/!\[.*?\]\(.*?\)/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/\*\*(.*?)\*\*/g, "$1").replace(/__(.*?)__/g, "$1").replace(/\*(.*?)\*/g, "$1").replace(/_(.*?)_/g, "$1").replace(/`(.*?)`/g, "$1").replace(/```[\s\S]*?```/g, "").replace(/\n{2,}/g, "\n").replace(/-{3,}/g, "").replace(/^\s*-\s+/gm, "").replace(/\|/g, "").trim();
 }
@@ -3398,7 +3530,6 @@ function useHowlerParagraph(props, emit) {
     return new howler.Howl({
       src: [url2],
       format: ["mp3", "wav", "aac"],
-      // 事件处理
       onplay: () => {
         broadcast.value = TickerStatus.playing;
       },
@@ -4070,6 +4201,7 @@ var _sfc_main = defineComponent({
     const [theData, handleSetData] = useDataComputed({
       default: []
     }, props2, emit);
+    const queue = new AsyncQueue();
     const addParagraph = (paragraph) => {
       const k = theData.value.length;
       if (k === 0) {
@@ -4080,7 +4212,7 @@ var _sfc_main = defineComponent({
         v: paragraph
       });
     };
-    const processingParagraph = (paragraph) => {
+    const processingParagraph = async (paragraph) => {
       if (!props2.textToSpeech) {
         return;
       }
@@ -4091,7 +4223,9 @@ var _sfc_main = defineComponent({
       if (!value) {
         return;
       }
-      return props2.textToSpeech(`${value}`).then(async (res) => {
+      const resPromise = props2.textToSpeech(value);
+      await queue.wait();
+      return resPromise.then(async (res) => {
         if (res instanceof Blob) {
           paragraph.blob = res;
           paragraph.url = await blobToDataURL(res);
@@ -4101,6 +4235,7 @@ var _sfc_main = defineComponent({
         }
       }).then(async () => {
         await props2.processing?.(paragraph);
+        queue.shift();
       });
     };
     const currentIndex = ref(0);

package/components/broadcasting-markdown/src/index.vue.d.ts

@@ -80,7 +80,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     theData: import("vue").ComputedRef<Paragraph[]>;
     ParagraphStatus: typeof ParagraphStatus;
     fulfilledTextValue: import("vue").ComputedRef<string>;
-    processingParagraph: (paragraph: Paragraph) => Promise<void> | undefined;
+    processingParagraph: (paragraph: Paragraph) => Promise<void>;
     setData: (obj: any, e: import("@vunk/core").SetDataEvent) => void;
     Broadcast: typeof TickerStatus;
     isParagraphEnabled: (currentIndex: number) => boolean;

package/components/bubble-list/index.mjs

@@ -4,7 +4,7 @@ import { ElAutoResizer } from 'element-plus';
 import { a as arrow_down_bold_default } from '../index2.mjs';
 import { useResizeObserver } from '@vueuse/core';
 import { VkScrollbar } from '@vunk/plus/components/scrollbar';
-import { Bubble } from 'vue-element-plus-x';
+import { Bubble } from '@vunk/plus/element/bubble';
 import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 import { noop } from '@vunk/shared/function';
 export { Role } from '@vunk/plus/components/agent-chat-provider';

package/components/bubble-list/src/core/index.vue.d.ts

@@ -917,164 +917,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         tabindex: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     readonly Bubble: {
-        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & Readonly<{
-            onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onAvatarError?: ((e: Event) => any) | undefined;
-        }>, {
-            interrupt: () => void;
-            continue: () => void;
-            restart: () => void;
-            destroy: () => void;
-            renderedContent: ComputedRef<string>;
-            isTyping: Ref<boolean>;
-            progress: ComputedRef<number>;
-        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            start: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-            finish: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-            writing: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-            avatarError: (e: Event) => any;
-        }, import("vue").PublicProps, {
-            maxWidth: string;
-            noStyle: boolean;
-            content: string;
-            placement: "start" | "end";
-            avatar: string;
-            variant: "filled" | "borderless" | "outlined" | "shadow";
-            avatarSize: string;
-            avatarGap: string;
-            avatarShape: "circle" | "square";
-            avatarSrcSet: string;
-            avatarAlt: string;
-            avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
-        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
-            typewriterRef: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue-element-plus-x/./types/Typewriter").TypewriterProps> & Readonly<{
-                onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            }>, {
-                interrupt: () => void;
-                continue: () => void;
-                restart: () => void;
-                destroy: () => void;
-                renderedContent: ComputedRef<string>;
-                isTyping: Ref<boolean>;
-                progress: ComputedRef<number>;
-            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-                start: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                finish: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                writing: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-            }, import("vue").PublicProps, {
-                content: string;
-                isMarkdown: boolean;
-                typing: boolean | import("vue-element-plus-x/./types/Typewriter").TypingConfig;
-                isFog: boolean | import("vue-element-plus-x/./types/Typewriter").TypingFogfig;
-            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
-                typeWriterRef: HTMLDivElement;
-                markdownContentRef: HTMLDivElement;
-            }, HTMLDivElement, import("vue").ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<import("vue-element-plus-x/./types/Typewriter").TypewriterProps> & Readonly<{
-                onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            }>, {
-                interrupt: () => void;
-                continue: () => void;
-                restart: () => void;
-                destroy: () => void;
-                renderedContent: ComputedRef<string>;
-                isTyping: Ref<boolean>;
-                progress: ComputedRef<number>;
-            }, {}, {}, {}, {
-                content: string;
-                isMarkdown: boolean;
-                typing: boolean | import("vue-element-plus-x/./types/Typewriter").TypingConfig;
-                isFog: boolean | import("vue-element-plus-x/./types/Typewriter").TypingFogfig;
-            }> | null;
-        }, any, import("vue").ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & Readonly<{
-            onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onAvatarError?: ((e: Event) => any) | undefined;
-        }>, {
-            interrupt: () => void;
-            continue: () => void;
-            restart: () => void;
-            destroy: () => void;
-            renderedContent: ComputedRef<string>;
-            isTyping: Ref<boolean>;
-            progress: ComputedRef<number>;
-        }, {}, {}, {}, {
-            maxWidth: string;
-            noStyle: boolean;
-            content: string;
-            placement: "start" | "end";
-            avatar: string;
-            variant: "filled" | "borderless" | "outlined" | "shadow";
-            avatarSize: string;
-            avatarGap: string;
-            avatarShape: "circle" | "square";
-            avatarSrcSet: string;
-            avatarAlt: string;
-            avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
-        }>;
+        new (...args: any[]): any;
         __isFragment?: never;
         __isTeleport?: never;
         __isSuspense?: never;
-    } & import("vue").ComponentOptionsBase<Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & Readonly<{
-        onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-        onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-        onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-        onAvatarError?: ((e: Event) => any) | undefined;
-    }>, {
-        interrupt: () => void;
-        continue: () => void;
-        restart: () => void;
-        destroy: () => void;
-        renderedContent: ComputedRef<string>;
-        isTyping: Ref<boolean>;
-        progress: ComputedRef<number>;
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        start: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-        finish: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-        writing: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-        avatarError: (e: Event) => any;
-    }, string, {
-        maxWidth: string;
-        noStyle: boolean;
-        content: string;
-        placement: "start" | "end";
-        avatar: string;
-        variant: "filled" | "borderless" | "outlined" | "shadow";
-        avatarSize: string;
-        avatarGap: string;
-        avatarShape: "circle" | "square";
-        avatarSrcSet: string;
-        avatarAlt: string;
-        avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
-    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-        $slots: {
-            avatar?(_: {}): any;
-            header?(_: {}): any;
-            content?(_: {}): any;
-            loading?(_: {}): any;
-            footer?(_: {}): any;
-        };
-    });
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<Record<string | symbol, any>>>, Record<string | symbol, any>, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        [x: string]: any;
+        [x: symbol]: any;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install(app: import("vue").App): void;
+    };
     loadingBg: {
         new (...args: any[]): any;
         __isFragment?: never;

package/components/bubble-list/src/index.vue.d.ts

@@ -1249,164 +1249,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             tabindex: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
         }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
         readonly Bubble: {
-            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & Readonly<{
-                onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onAvatarError?: ((e: Event) => any) | undefined;
-            }>, {
-                interrupt: () => void;
-                continue: () => void;
-                restart: () => void;
-                destroy: () => void;
-                renderedContent: ComputedRef<string>;
-                isTyping: Ref<boolean>;
-                progress: ComputedRef<number>;
-            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                start: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                finish: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                writing: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                avatarError: (e: Event) => any;
-            }, import("vue").PublicProps, {
-                maxWidth: string;
-                noStyle: boolean;
-                content: string;
-                placement: "start" | "end";
-                avatar: string;
-                variant: "filled" | "borderless" | "outlined" | "shadow";
-                avatarSize: string;
-                avatarGap: string;
-                avatarShape: "circle" | "square";
-                avatarSrcSet: string;
-                avatarAlt: string;
-                avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
-            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
-                typewriterRef: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue-element-plus-x/./types/Typewriter").TypewriterProps> & Readonly<{
-                    onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                    onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                    onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                }>, {
-                    interrupt: () => void;
-                    continue: () => void;
-                    restart: () => void;
-                    destroy: () => void;
-                    renderedContent: ComputedRef<string>;
-                    isTyping: Ref<boolean>;
-                    progress: ComputedRef<number>;
-                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-                    start: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                    finish: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                    writing: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-                }, import("vue").PublicProps, {
-                    content: string;
-                    isMarkdown: boolean;
-                    typing: boolean | import("vue-element-plus-x/./types/Typewriter").TypingConfig;
-                    isFog: boolean | import("vue-element-plus-x/./types/Typewriter").TypingFogfig;
-                }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
-                    typeWriterRef: HTMLDivElement;
-                    markdownContentRef: HTMLDivElement;
-                }, HTMLDivElement, import("vue").ComponentProvideOptions, {
-                    P: {};
-                    B: {};
-                    D: {};
-                    C: {};
-                    M: {};
-                    Defaults: {};
-                }, Readonly<import("vue-element-plus-x/./types/Typewriter").TypewriterProps> & Readonly<{
-                    onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                    onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                    onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                }>, {
-                    interrupt: () => void;
-                    continue: () => void;
-                    restart: () => void;
-                    destroy: () => void;
-                    renderedContent: ComputedRef<string>;
-                    isTyping: Ref<boolean>;
-                    progress: ComputedRef<number>;
-                }, {}, {}, {}, {
-                    content: string;
-                    isMarkdown: boolean;
-                    typing: boolean | import("vue-element-plus-x/./types/Typewriter").TypingConfig;
-                    isFog: boolean | import("vue-element-plus-x/./types/Typewriter").TypingFogfig;
-                }> | null;
-            }, any, import("vue").ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & Readonly<{
-                onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-                onAvatarError?: ((e: Event) => any) | undefined;
-            }>, {
-                interrupt: () => void;
-                continue: () => void;
-                restart: () => void;
-                destroy: () => void;
-                renderedContent: ComputedRef<string>;
-                isTyping: Ref<boolean>;
-                progress: ComputedRef<number>;
-            }, {}, {}, {}, {
-                maxWidth: string;
-                noStyle: boolean;
-                content: string;
-                placement: "start" | "end";
-                avatar: string;
-                variant: "filled" | "borderless" | "outlined" | "shadow";
-                avatarSize: string;
-                avatarGap: string;
-                avatarShape: "circle" | "square";
-                avatarSrcSet: string;
-                avatarAlt: string;
-                avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
-            }>;
+            new (...args: any[]): any;
             __isFragment?: never;
             __isTeleport?: never;
             __isSuspense?: never;
-        } & import("vue").ComponentOptionsBase<Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & Readonly<{
-            onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
-            onAvatarError?: ((e: Event) => any) | undefined;
-        }>, {
-            interrupt: () => void;
-            continue: () => void;
-            restart: () => void;
-            destroy: () => void;
-            renderedContent: ComputedRef<string>;
-            isTyping: Ref<boolean>;
-            progress: ComputedRef<number>;
-        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            start: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-            finish: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-            writing: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
-            avatarError: (e: Event) => any;
-        }, string, {
-            maxWidth: string;
-            noStyle: boolean;
-            content: string;
-            placement: "start" | "end";
-            avatar: string;
-            variant: "filled" | "borderless" | "outlined" | "shadow";
-            avatarSize: string;
-            avatarGap: string;
-            avatarShape: "circle" | "square";
-            avatarSrcSet: string;
-            avatarAlt: string;
-            avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
-        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-            $slots: {
-                avatar?(_: {}): any;
-                header?(_: {}): any;
-                content?(_: {}): any;
-                loading?(_: {}): any;
-                footer?(_: {}): any;
-            };
-        });
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<Record<string | symbol, any>>>, Record<string | symbol, any>, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            [x: string]: any;
+            [x: symbol]: any;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+            install(app: import("vue").App): void;
+        };
         loadingBg: {
             new (...args: any[]): any;
             __isFragment?: never;