@antdv-next/x-sdk 0.0.1 → 0.0.3

package/dist/node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/vendor/tinyrainbow.js

@@ -0,0 +1,84 @@
+//#region ../../node_modules/.pnpm/@voidzero-dev+vite-plus-test@0.1.14_@types+node@24.12.0_@voidzero-dev+vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/vendor/tinyrainbow.mjs
+var d = {
+	reset: [0, 0],
+	bold: [
+		1,
+		22,
+		"\x1B[22m\x1B[1m"
+	],
+	dim: [
+		2,
+		22,
+		"\x1B[22m\x1B[2m"
+	],
+	italic: [3, 23],
+	underline: [4, 24],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29],
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	gray: [90, 39],
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49],
+	blackBright: [90, 39],
+	redBright: [91, 39],
+	greenBright: [92, 39],
+	yellowBright: [93, 39],
+	blueBright: [94, 39],
+	magentaBright: [95, 39],
+	cyanBright: [96, 39],
+	whiteBright: [97, 39],
+	bgBlackBright: [100, 49],
+	bgRedBright: [101, 49],
+	bgGreenBright: [102, 49],
+	bgYellowBright: [103, 49],
+	bgBlueBright: [104, 49],
+	bgMagentaBright: [105, 49],
+	bgCyanBright: [106, 49],
+	bgWhiteBright: [107, 49]
+};
+function g(e) {
+	return String(e);
+}
+g.open = "";
+g.close = "";
+function h() {
+	let e = typeof process != "undefined" ? process : void 0, n = (e == null ? void 0 : e.env) || {}, a = n.FORCE_TTY !== "false", i = (e == null ? void 0 : e.argv) || [];
+	return !("NO_COLOR" in n || i.includes("--no-color")) && ("FORCE_COLOR" in n || i.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && n.TERM !== "dumb" || "CI" in n) || typeof window != "undefined" && !!window.chrome;
+}
+function f() {
+	let e = h(), n = (r, t, u, o) => {
+		let l = "", s = 0;
+		do
+			l += r.substring(s, o) + u, s = o + t.length, o = r.indexOf(t, s);
+		while (~o);
+		return l + r.substring(s);
+	}, a = (r, t, u = r) => {
+		let o = (l) => {
+			let s = String(l), b = s.indexOf(t, r.length);
+			return ~b ? r + n(s, t, u, b) + t : r + s + t;
+		};
+		return o.open = r, o.close = t, o;
+	}, i = { isColorSupported: e }, c = (r) => `\x1B[${r}m`;
+	for (let r in d) {
+		let t = d[r];
+		i[r] = e ? a(c(t[0]), c(t[1]), t[2]) : g;
+	}
+	return i;
+}
+var C = f();
+//#endregion
+export { f as createColors, C as default, h as isSupported };

package/dist/x-chat/__tests__/index.test.d.ts

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

package/dist/x-chat/__tests__/index.test.js

@@ -0,0 +1,258 @@
+import AbstractChatProvider from "../../chat-providers/AbstractChatProvider.js";
+import { AbstractXRequestClass } from "../../x-request/index.js";
+import { chatMessagesStoreHelper } from "../store.js";
+import useXChat from "../index.js";
+import { h as describe, m as it } from "../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/runner/chunk-artifact.js";
+import { g as globalExpect, v as vi } from "../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/chunks/test.CBQUpOM3.js";
+import { computed, effectScope, nextTick, reactive, readonly, ref } from "vue";
+//#region src/x-chat/__tests__/index.test.ts
+var MockManualRequest = class extends AbstractXRequestClass {
+	shouldFail;
+	_asyncHandler = Promise.resolve();
+	_state = reactive({
+		isTimeout: false,
+		isStreamTimeout: false,
+		isRequesting: false
+	});
+	constructor(shouldFail) {
+		super("https://mock.request", { manual: true });
+		this.shouldFail = shouldFail;
+	}
+	get asyncHandler() {
+		return this._asyncHandler;
+	}
+	get isTimeout() {
+		return this._state.isTimeout;
+	}
+	get isStreamTimeout() {
+		return this._state.isStreamTimeout;
+	}
+	get isRequesting() {
+		return this._state.isRequesting;
+	}
+	get manual() {
+		return true;
+	}
+	get state() {
+		return readonly(this._state);
+	}
+	run(params) {
+		const callbacks = this.options.callbacks;
+		this._state.isRequesting = true;
+		this._asyncHandler = new Promise((resolve) => {
+			setTimeout(() => {
+				const headers = new Headers({ "content-type": "application/json" });
+				if (this.shouldFail.value) callbacks?.onError?.(/* @__PURE__ */ new Error("MockError"), { error: { message: "mock failed" } }, headers);
+				else {
+					const chunk = `echo:${params?.input || ""}`;
+					callbacks?.onUpdate?.(chunk, headers);
+					callbacks?.onSuccess?.([chunk], headers);
+				}
+				this._state.isRequesting = false;
+				resolve();
+			}, 0);
+		});
+	}
+	abort() {
+		this._state.isRequesting = false;
+	}
+};
+var MockProvider = class extends AbstractChatProvider {
+	transformParams(requestParams) {
+		return { input: requestParams.input || "" };
+	}
+	transformLocalMessage(requestParams) {
+		return requestParams.input || "";
+	}
+	transformMessage(info) {
+		if (info.chunk) return info.chunk;
+		if (Array.isArray(info.chunks) && info.chunks.length > 0) return info.chunks[info.chunks.length - 1];
+		return info.originMessage || "";
+	}
+};
+var DeferredManualRequest = class extends AbstractXRequestClass {
+	_state = reactive({
+		isTimeout: false,
+		isStreamTimeout: false,
+		isRequesting: false
+	});
+	callbacks;
+	params;
+	constructor() {
+		super("https://mock.request", { manual: true });
+	}
+	get asyncHandler() {
+		return Promise.resolve();
+	}
+	get isTimeout() {
+		return this._state.isTimeout;
+	}
+	get isStreamTimeout() {
+		return this._state.isStreamTimeout;
+	}
+	get isRequesting() {
+		return this._state.isRequesting;
+	}
+	get manual() {
+		return true;
+	}
+	get state() {
+		return readonly(this._state);
+	}
+	run(params) {
+		this.params = params;
+		this.callbacks = this.options.callbacks;
+		this._state.isRequesting = true;
+	}
+	resolve() {
+		const headers = new Headers({ "content-type": "application/json" });
+		const chunk = `echo:${this.params?.input || ""}`;
+		this.callbacks?.onUpdate?.(chunk, headers);
+		this.callbacks?.onSuccess?.([chunk], headers);
+		this._state.isRequesting = false;
+	}
+	abort() {
+		this._state.isRequesting = false;
+	}
+};
+describe("useXChat", () => {
+	it("uses reactive requestPlaceholder and requestFallback refs", async () => {
+		vi.useFakeTimers();
+		const shouldFail = ref(false);
+		const request = new MockManualRequest(shouldFail);
+		const provider = new MockProvider({ request });
+		const requestPlaceholder = ref("Thinking #1");
+		const requestFallback = ref("Fallback #1");
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({
+			provider,
+			requestPlaceholder,
+			requestFallback
+		}));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		chat.onRequest({ input: "hello" });
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("loading");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Thinking #1");
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		requestPlaceholder.value = "Thinking #2";
+		chat.onRequest({ input: "again" });
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("loading");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Thinking #2");
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		shouldFail.value = true;
+		chat.onRequest({ input: "error" });
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("error");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Fallback #1");
+		requestFallback.value = "Fallback #2";
+		chat.onRequest({ input: "error-again" });
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("error");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Fallback #2");
+		scope.stop();
+		vi.useRealTimers();
+	});
+	it("refreshes default messages when defaultMessages ref changes", async () => {
+		const defaultMessages = ref([{ message: "history-1" }]);
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({ defaultMessages }));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		await Promise.resolve();
+		await nextTick();
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["history-1"]);
+		defaultMessages.value = [{ message: "history-2" }];
+		await nextTick();
+		await Promise.resolve();
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["history-2"]);
+		scope.stop();
+	});
+	it("accepts computed provider refs", async () => {
+		vi.useFakeTimers();
+		const shouldFail = ref(false);
+		const provider = computed(() => new MockProvider({ request: new MockManualRequest(shouldFail) }));
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({ provider }));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		chat.onRequest({ input: "provider" });
+		await vi.runAllTimersAsync();
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("success");
+		scope.stop();
+		vi.useRealTimers();
+	});
+	it("derives parsedMessages from parser output", async () => {
+		vi.useFakeTimers();
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({ parser: (message) => [message.toUpperCase(), `${message}!`] }));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		await Promise.resolve();
+		await nextTick();
+		chat.setMessages([{
+			id: "msg_1",
+			message: "hello",
+			status: "success"
+		}]);
+		await vi.advanceTimersByTimeAsync(60);
+		await nextTick();
+		globalExpect(chat.parsedMessages.value).toEqual([{
+			id: "msg_1_0",
+			message: "HELLO",
+			status: "success"
+		}, {
+			id: "msg_1_1",
+			message: "hello!",
+			status: "success"
+		}]);
+		scope.stop();
+		vi.useRealTimers();
+	});
+	it("keeps streaming updates isolated to the request conversation after switching", async () => {
+		const activeConversationKey = ref("a");
+		const requestA = new DeferredManualRequest();
+		const requestB = new DeferredManualRequest();
+		const providers = {
+			a: new MockProvider({ request: requestA }),
+			b: new MockProvider({ request: requestB })
+		};
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({
+			provider: computed(() => providers[activeConversationKey.value]),
+			conversationKey: activeConversationKey
+		}));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		await Promise.resolve();
+		await nextTick();
+		chat.onRequest({ input: "from-a" });
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["from-a"]);
+		activeConversationKey.value = "b";
+		await nextTick();
+		globalExpect(chat.messages.value).toEqual([]);
+		requestA.resolve();
+		await nextTick();
+		globalExpect(chat.messages.value).toEqual([]);
+		globalExpect(chatMessagesStoreHelper.getMessages("a")?.map((item) => ({
+			message: item.message,
+			status: item.status
+		}))).toEqual([{
+			message: "from-a",
+			status: "local"
+		}, {
+			message: "echo:from-a",
+			status: "success"
+		}]);
+		globalExpect(chatMessagesStoreHelper.getMessages("b")).toEqual([]);
+		activeConversationKey.value = "a";
+		await nextTick();
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["from-a", "echo:from-a"]);
+		scope.stop();
+	});
+});
+//#endregion

package/dist/x-chat/index.d.ts

@@ -1,4 +1,4 @@
-import { Ref } from 'vue';
+import { MaybeRef } from 'vue';
 import { AnyObject } from '../_util/types';
 import { ConversationData } from '../x-conversations';
 import { SSEOutput } from '../x-stream';
@@ -26,18 +26,19 @@ type RequestFallbackFn<Input, MessageInfoType, Message> = (requestParams: Partia
 export type RequestParams<Message> = {
     [Key: PropertyKey]: Message;
 } & AnyObject;
-type MaybeRef<T> = T | Ref<T>;
+type ParserFn<ChatMessage, BubbleMessage> = (message: ChatMessage) => BubbleMessage | BubbleMessage[];
+type DefaultMessagesFn<ChatMessage extends SimpleType> = ((info: {
+    conversationKey?: ConversationData["key"];
+}) => Promise<DefaultMessageInfo<ChatMessage>[]>) | ((info?: {
+    conversationKey?: ConversationData["key"];
+}) => DefaultMessageInfo<ChatMessage>[]);
 export interface XChatConfig<ChatMessage extends SimpleType = string, BubbleMessage extends SimpleType = ChatMessage, Input = ChatMessage, Output = ChatMessage> {
-    provider?: AbstractChatProvider<ChatMessage, Input, Output>;
+    provider?: MaybeRef<AbstractChatProvider<ChatMessage, Input, Output>>;
     conversationKey?: MaybeRef<ConversationData["key"] | undefined>;
-    defaultMessages?: DefaultMessageInfo<ChatMessage>[] | ((info: {
-        conversationKey?: ConversationData["key"];
-    }) => Promise<DefaultMessageInfo<ChatMessage>[]>) | ((info?: {
-        conversationKey?: ConversationData["key"];
-    }) => DefaultMessageInfo<ChatMessage>[]);
-    parser?: (message: ChatMessage) => BubbleMessage | BubbleMessage[];
-    requestPlaceholder?: ChatMessage | RequestPlaceholderFn<Input, ChatMessage>;
-    requestFallback?: ChatMessage | RequestFallbackFn<Input, MessageInfo<ChatMessage>, ChatMessage>;
+    defaultMessages?: MaybeRef<DefaultMessageInfo<ChatMessage>[]> | DefaultMessagesFn<ChatMessage>;
+    parser?: ParserFn<ChatMessage, BubbleMessage> | undefined;
+    requestPlaceholder?: MaybeRef<ChatMessage> | RequestPlaceholderFn<Input, ChatMessage>;
+    requestFallback?: MaybeRef<ChatMessage> | RequestFallbackFn<Input, MessageInfo<ChatMessage>, ChatMessage>;
 }
 export interface MessageInfo<Message extends SimpleType> {
     id: number | string;
@@ -58,18 +59,8 @@ export default function useXChat<ChatMessage extends SimpleType = string, Parsed
     readonly onRequest: (requestParams: Partial<Input>, opts?: {
         extraInfo: AnyObject;
     }) => void;
-    readonly isDefaultMessagesRequesting: Ref<boolean, boolean>;
-    readonly messages: Ref<{
-        id: number | string;
-        message: import('vue').UnwrapRef<ChatMessage>;
-        status: MessageStatus;
-        extraInfo?: AnyObject | undefined;
-    }[], MessageInfo<ChatMessage>[] | {
-        id: number | string;
-        message: import('vue').UnwrapRef<ChatMessage>;
-        status: MessageStatus;
-        extraInfo?: AnyObject | undefined;
-    }[]>;
+    readonly isDefaultMessagesRequesting: Readonly<import('vue').Ref<boolean, boolean>>;
+    readonly messages: import('vue').ShallowRef<MessageInfo<ChatMessage>[], MessageInfo<ChatMessage>[]>;
     readonly parsedMessages: import('vue').ComputedRef<MessageInfo<ParsedMessage>[]>;
     readonly setMessages: (updater: MessageInfo<ChatMessage>[] | ((ori: MessageInfo<ChatMessage>[]) => MessageInfo<ChatMessage>[])) => boolean;
     readonly removeMessage: (id: string | number) => boolean;