@vunk/plus 1.8.0 → 1.8.1

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

@@ -0,0 +1,8 @@
+import VkAgentChatProvider from './src/index.vue';
+export * from './src/const';
+export * from './src/const-roles';
+export { type MessageView, MessageViewManager } from './src/MessageView';
+export * as __VkAgentChatProvider from './src/types';
+export { useAgentChat } from './src/use';
+export { VkAgentChatProvider, };
+export default VkAgentChatProvider;

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

@@ -0,0 +1,29 @@
+export interface MessageView {
+    content: string;
+    type: string;
+    updating: boolean;
+}
+export declare class MessageViewManager {
+    private views;
+    getViews(): MessageView[];
+    createView(view: MessageView): void;
+    /**
+     * @description 创建或更新最后一个 view
+     */
+    upsertView(data: MessageView, callbacks?: {
+        onCreate?: (view: MessageView) => void;
+        onUpdate?: (view: MessageView) => void;
+    }): MessageView;
+    /**
+     * @description 获取当前view 的上一个 view
+     */
+    getPrevView(view: MessageView): MessageView | undefined;
+    /**
+     * @description 获取最后一个正在更新的 view
+     */
+    getLastUpdatingView(type: string): MessageView | undefined;
+    /**
+     * @description 所有 view 更新结束
+     */
+    allViewUpdated(): void;
+}

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

@@ -0,0 +1,3 @@
+import type { NormalObject } from '@vunk/shared';
+import type { RestFetchReaderOnmessage } from '@vunk/shared/fetch';
+export declare function agentRequest(onmessage: RestFetchReaderOnmessage, data: NormalObject): Promise<void>;

package/components/agent-chat-provider/src/const-roles.d.ts

@@ -0,0 +1,8 @@
+import type { RoleMedia } from './types';
+export declare enum Role {
+    User = "user",
+    Assistant = "assistant",
+    Broadcasting = "broadcasting"
+}
+export declare const roleOptions: RoleMedia[];
+export declare const roleMap: Record<Role, RoleMedia>;

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

@@ -0,0 +1 @@
+export declare const ChatAgentInjectKey = "vk_agent_chat_inject_key";

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

@@ -0,0 +1,22 @@
+import type { AnyFunc } from '@vunk/shared';
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    request: {
+        type: PropType<AnyFunc>;
+    };
+    parser: {
+        type: PropType<AnyFunc>;
+    };
+}>, import("vue").Slot<any> | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: null;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    request: {
+        type: PropType<AnyFunc>;
+    };
+    parser: {
+        type: PropType<AnyFunc>;
+    };
+}>> & Readonly<{
+    onLoad?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,56 @@
+import type { __VkBubbleTemplates } from '@vunk/plus/components/bubble-templates';
+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;
+    messages?: Message[];
+} & NormalObject;
+export interface AgentChatContext {
+    agent: ComputedRef<XAgent<AgentMessage>>;
+    chat: ReturnType<typeof useXChat<AgentMessage, BubbleMessage>>;
+    simplicity: {
+        onRequest: (message: string) => void;
+        items: ComputedRef<BubbleItem[]>;
+    };
+}
+export type Request = RequestFn<AgentMessage, RequestParams<AgentMessage>, RequestOutput>;
+export type Parser = (message: Partial<AgentMessage>) => MaybeArray<BubbleMessage>;
+export type RequestOutput = AgentMessage & SSEOutput;
+/**
+ * @description   useXAgent request onSuccess 发送的数据
+ */
+export type AgentMessage = Partial<BubbleMessage> & {
+    seviceLoading?: boolean;
+    seviceEnd?: boolean;
+    views?: MessageView[];
+};
+/**
+ * @description useXChat parser 解析数据
+ */
+export type BubbleMessage = Partial<BubbleListItemProps> & {
+    role: string;
+    content: string;
+    /**
+     * @description 服务端请求是否完成
+     */
+    seviceEnd?: boolean;
+    thinkingStatus?: 'start' | 'thinking' | 'end' | 'error';
+    thinkingContent?: string;
+    meta?: NormalObject;
+    abortController?: AbortController;
+    templateType?: string;
+    [key: string]: any;
+};
+export type BubbleItem = BubbleItemBasic & __VkBubbleTemplates.RenderItem;
+export type RoleMedia = RoleMediaBasic & __VkBubbleTemplates.RenderItem;
+export type BubbleItemModule = 'Thinking';
+export interface BubbleItemBasic extends BubbleMessage {
+    key: string;
+    modules?: BubbleItemModule[];
+}
+export interface RoleMediaBasic extends Partial<BubbleItemBasic>, Media {
+    value: string;
+}

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

@@ -0,0 +1,6 @@
+import type { SSEOutput } from 'ant-design-x-vue';
+import type { AgentChatContext, AgentMessage, 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 useAgentChat(): AgentChatContext;

package/components/avatar/index.d.ts

@@ -0,0 +1,4 @@
+import VkAvatar from './src/index.vue';
+export * as __VkAvatar from './src/types';
+export { VkAvatar, };
+export default VkAvatar;

package/components/avatar/src/ctx.d.ts

@@ -0,0 +1,6 @@
+import type { avatarProps } from 'element-plus';
+export declare const props: typeof avatarProps & {
+    background: never;
+    color: never;
+};
+export declare const emits: {};

package/components/avatar/src/index.vue.d.ts

@@ -0,0 +1,261 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly size: {
+        readonly type: import("vue").PropType<number | "" | "small" | "default" | "large">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    readonly shape: {
+        readonly type: import("vue").PropType<"circle" | "square">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "circle";
+    };
+    readonly icon: {
+        readonly type: import("vue").PropType<string | import("vue").Component>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly src: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    readonly alt: StringConstructor;
+    readonly srcSet: StringConstructor;
+    readonly fit: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "cover";
+    };
+} & {
+    background: never;
+    color: never;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly size: {
+        readonly type: import("vue").PropType<number | "" | "small" | "default" | "large">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    readonly shape: {
+        readonly type: import("vue").PropType<"circle" | "square">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "circle";
+    };
+    readonly icon: {
+        readonly type: import("vue").PropType<string | import("vue").Component>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly src: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    readonly alt: StringConstructor;
+    readonly srcSet: StringConstructor;
+    readonly fit: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "cover";
+    };
+} & {
+    background: never;
+    color: never;
+}>> & Readonly<{}>, {
+    readonly size: number | "" | "small" | "default" | "large";
+    readonly shape: "circle" | "square";
+    readonly src: string;
+    readonly fit: any;
+}, {}, {
+    ElAvatar: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<number | "" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly shape: {
+                readonly type: import("vue").PropType<"circle" | "square">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "circle";
+            };
+            readonly icon: {
+                readonly type: import("vue").PropType<string | import("vue").Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly src: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly alt: StringConstructor;
+            readonly srcSet: StringConstructor;
+            readonly fit: {
+                readonly type: import("vue").PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "cover";
+            };
+        }>> & {
+            onError?: ((evt: Event) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            error: (evt: Event) => void;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
+            readonly size: number | "" | "small" | "default" | "large";
+            readonly shape: "circle" | "square";
+            readonly src: string;
+            readonly fit: any;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<number | "" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly shape: {
+                readonly type: import("vue").PropType<"circle" | "square">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "circle";
+            };
+            readonly icon: {
+                readonly type: import("vue").PropType<string | import("vue").Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly src: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly alt: StringConstructor;
+            readonly srcSet: StringConstructor;
+            readonly fit: {
+                readonly type: import("vue").PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "cover";
+            };
+        }>> & {
+            onError?: ((evt: Event) => any) | undefined;
+        }, {}, {}, {}, {}, {
+            readonly size: number | "" | "small" | "default" | "large";
+            readonly shape: "circle" | "square";
+            readonly src: string;
+            readonly fit: any;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        readonly size: {
+            readonly type: import("vue").PropType<number | "" | "small" | "default" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly shape: {
+            readonly type: import("vue").PropType<"circle" | "square">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "circle";
+        };
+        readonly icon: {
+            readonly type: import("vue").PropType<string | import("vue").Component>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly src: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly alt: StringConstructor;
+        readonly srcSet: StringConstructor;
+        readonly fit: {
+            readonly type: import("vue").PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "cover";
+        };
+    }>> & {
+        onError?: ((evt: Event) => any) | undefined;
+    }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        error: (evt: Event) => void;
+    }, string, {
+        readonly size: number | "" | "small" | "default" | "large";
+        readonly shape: "circle" | "square";
+        readonly src: string;
+        readonly fit: any;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) & import("vue").Plugin;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/avatar/src/types.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import VkBroadcastingMarkdown from './src/index.vue';
+export * from './src/const';
+export * as _VkBroadcastingMarkdownCtx from './src/ctx';
+export * as __VkBroadcastingMarkdown from './src/types';
+export { useHowlerParagraph } from './src/use';
+export { VkBroadcastingMarkdown, };
+export default VkBroadcastingMarkdown;

package/components/broadcasting-markdown/src/const.d.ts

@@ -0,0 +1,13 @@
+import { TickerStatus } from '@vunk/shared/enum';
+export declare function defaultRender(mdText: string): string;
+export declare enum ParagraphStatus {
+    initial = "initial",
+    /**
+     * @description 处理中, 通常用于需要对段落进行异步处理
+     */
+    processing = "processing",
+    pending = "pending",
+    fulfilled = "fulfilled",
+    rejected = "rejected"
+}
+export declare const Broadcast: typeof TickerStatus;

package/components/broadcasting-markdown/src/ctx.d.ts

@@ -0,0 +1,126 @@
+import type { SetDataEvent } from '@vunk/core';
+import type { Deferred } from '@vunk/shared/promise';
+import type { PropType } from 'vue';
+import type { Paragraph, ParagraphLoadEvent, TextToSpeech } from './types';
+import { TickerStatus } from '@vunk/shared/enum';
+import { defaultRender } from './const';
+export declare const props: {
+    /**
+     * @description md文本转纯文本的函数
+     */
+    render: {
+        type: PropType<(text: string) => string>;
+        default: typeof defaultRender;
+    };
+    /**
+     *  @description 段落详情
+     */
+    data: {
+        type: {
+            (arrayLength: number): Paragraph[];
+            (...items: Paragraph[]): Paragraph[];
+            new (arrayLength: number): Paragraph[];
+            new (...items: Paragraph[]): Paragraph[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: undefined;
+    };
+    /**
+     * @description md 文本
+     */
+    source: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     *  @description 游标阅读延迟
+     */
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * @description 段落切割符号
+     */
+    separators: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => string[];
+    };
+    /**
+     * @description 组件内会根据当前游标是否和 source 长度一致来判断，是否持续阅读, 当一致时，会关闭阅读状态。但若设置为 true，则会持续阅读, 这在动态接收数据时会有用
+     */
+    keepRead: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description 是否使用自定义语音合成
+     */
+    textToSpeech: {
+        type: PropType<TextToSpeech>;
+        default: undefined;
+    };
+    /**
+     * @description 段落处理函数
+     */
+    processing: {
+        type: PropType<(paragraph: Paragraph) => void>;
+        default: import("@vunk/shared").AnyFunc;
+    };
+    status: {
+        type: PropType<TickerStatus>;
+        default: TickerStatus;
+    };
+    paragraphMinlength: {
+        type: NumberConstructor;
+        default: number;
+    };
+};
+export declare const emits: {
+    setData: (e: SetDataEvent) => SetDataEvent;
+    'update:status': (_: TickerStatus) => boolean;
+    paragraphLoad: (_: ParagraphLoadEvent) => boolean;
+    complete: () => boolean;
+};
+export declare const paragraphProps: {
+    data: {
+        type: PropType<Paragraph>;
+        default: () => {};
+    };
+    deferred: {
+        type: PropType<Deferred<any>>;
+        required: true;
+    };
+    render: {
+        type: PropType<(text: string) => string>;
+        default: typeof defaultRender;
+    };
+};
+export declare const paragraphEmits: {
+    setData: (e: SetDataEvent<keyof Paragraph>) => SetDataEvent<keyof Paragraph>;
+    load: (_: ParagraphLoadEvent) => boolean;
+};

package/components/broadcasting-markdown/src/howler-speech.vue.d.ts

@@ -0,0 +1,58 @@
+import type { PropType } from 'vue';
+import { TickerStatus } from '@vunk/shared/enum';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * 语音资源
+     */
+    source: {
+        type: StringConstructor;
+        default: string;
+    };
+    status: {
+        type: PropType<TickerStatus>;
+        default: TickerStatus;
+    };
+}>, {
+    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        /**
+         * 语音资源
+         */
+        source: {
+            type: StringConstructor;
+            default: string;
+        };
+        status: {
+            type: PropType<TickerStatus>;
+            default: TickerStatus;
+        };
+    }>> & Readonly<{
+        "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+        onError?: ((...args: any[]) => any) | undefined;
+        onLoad?: ((...args: any[]) => any) | undefined;
+    }> & {}>;
+    emit: ((event: "update:status", ...args: any[]) => void) & ((event: "error", ...args: any[]) => void) & ((event: "load", ...args: any[]) => void);
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:status': null;
+    load: null;
+    error: null;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * 语音资源
+     */
+    source: {
+        type: StringConstructor;
+        default: string;
+    };
+    status: {
+        type: PropType<TickerStatus>;
+        default: TickerStatus;
+    };
+}>> & Readonly<{
+    "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
+    onLoad?: ((...args: any[]) => any) | undefined;
+}>, {
+    source: string;
+    status: TickerStatus;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;