@antdv-next/x-sdk 0.0.1 → 0.0.2

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

@@ -20,10 +20,12 @@ export declare class ChatMessagesStore<T extends {
     private pendingEmit;
     private readonly throttleInterval;
     private isDestroyed;
+    private defaultMessagesLoader;
     private emitListeners;
     private throttledEmitListeners;
     constructor(defaultMessages: () => Promise<T[]>, conversationKey?: ConversationKey);
     private initializeMessages;
+    refreshDefaultMessages: () => boolean;
     private setSnapshotResult;
     private setMessagesInternal;
     setMessages: (messages: T[] | ((ori: T[]) => T[])) => boolean;

package/dist/{store-C1diHqNH.js → x-chat/store.js}

@@ -25,6 +25,7 @@ var ChatMessagesStore = class {
 	pendingEmit = false;
 	throttleInterval = 50;
 	isDestroyed = false;
+	defaultMessagesLoader;
 	emitListeners() {
 		this.listeners.forEach((listener) => {
 			listener();
@@ -44,27 +45,32 @@ var ChatMessagesStore = class {
 		} else this.pendingEmit = true;
 	}
 	constructor(defaultMessages, conversationKey) {
-		this.initializeMessages(defaultMessages, (value) => {
-			this.setSnapshotResult("isDefaultMessagesRequesting", value);
-			this.emitListeners();
-		});
+		this.defaultMessagesLoader = defaultMessages;
+		this.initializeMessages();
 		if (conversationKey) {
 			this.conversationKey = conversationKey;
 			chatMessagesStoreHelper.set(this.conversationKey, this);
 		}
 	}
-	async initializeMessages(defaultMessages, setDefaultMessagesRequesting) {
+	async initializeMessages() {
 		try {
-			setDefaultMessagesRequesting(true);
-			const messages = await defaultMessages();
+			this.setSnapshotResult("isDefaultMessagesRequesting", true);
+			this.emitListeners();
+			const messages = await this.defaultMessagesLoader();
 			if (!this.isDestroyed) this.setMessagesInternal(messages, false);
 		} catch (error) {
 			console.warn("Failed to initialize messages:", error);
 			if (!this.isDestroyed) this.setMessagesInternal([], false);
 		} finally {
-			setDefaultMessagesRequesting(false);
+			this.setSnapshotResult("isDefaultMessagesRequesting", false);
+			this.emitListeners();
 		}
 	}
+	refreshDefaultMessages = () => {
+		if (this.isDestroyed) return false;
+		this.initializeMessages();
+		return true;
+	};
 	setSnapshotResult = (key, value) => {
 		this.snapshotResult = {
 			...this.snapshotResult,
@@ -142,4 +148,4 @@ var ChatMessagesStore = class {
 	};
 };
 //#endregion
-export { chatMessagesStoreHelper as n, ChatMessagesStore as t };
+export { ChatMessagesStore, chatMessagesStoreHelper };

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

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

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

@@ -0,0 +1,36 @@
+import useXConversations from "../index.js";
+import { describe, it } from "../../node_modules/vitest/dist/@vitest/runner/chunk-artifact.js";
+import { globalExpect } from "../../node_modules/vitest/dist/chunks/test.CBQUpOM3.js";
+import { effectScope, nextTick, ref } from "vue";
+//#region src/x-conversations/__tests__/index.test.ts
+describe("useXConversations", () => {
+	it("syncs default conversations and active key from refs", async () => {
+		const defaultConversations = ref([{
+			key: "session_1",
+			label: "Session 1"
+		}, {
+			key: "session_2",
+			label: "Session 2"
+		}]);
+		const defaultActiveConversationKey = ref("session_1");
+		const scope = effectScope();
+		const conversationsHandler = scope.run(() => useXConversations({
+			defaultConversations,
+			defaultActiveConversationKey
+		}));
+		globalExpect(conversationsHandler).toBeTruthy();
+		if (!conversationsHandler) return;
+		globalExpect(conversationsHandler.conversations.value.map((item) => item.key)).toEqual(["session_1", "session_2"]);
+		globalExpect(conversationsHandler.activeConversationKey.value).toBe("session_1");
+		defaultConversations.value = [{
+			key: "session_3",
+			label: "Session 3"
+		}];
+		defaultActiveConversationKey.value = "session_3";
+		await nextTick();
+		globalExpect(conversationsHandler.conversations.value.map((item) => item.key)).toEqual(["session_3"]);
+		globalExpect(conversationsHandler.activeConversationKey.value).toBe("session_3");
+		scope.stop();
+	});
+});
+//#endregion

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

@@ -1,10 +1,11 @@
+import { MaybeRef } from 'vue';
 import { AnyObject } from '../_util/types';
 export interface ConversationData extends AnyObject {
     key: string;
 }
-interface XConversationConfig {
-    defaultConversations?: ConversationData[];
-    defaultActiveConversationKey?: string;
+export interface XConversationConfig {
+    defaultConversations?: MaybeRef<ConversationData[]>;
+    defaultActiveConversationKey?: MaybeRef<string>;
 }
 export default function useXConversations(config: XConversationConfig): {
     conversations: import('vue').ShallowRef<ConversationData[], ConversationData[]>;
@@ -17,4 +18,3 @@ export default function useXConversations(config: XConversationConfig): {
     setConversations: (list: ConversationData[]) => boolean;
     getMessages: (key: ConversationData["key"]) => any[] | undefined;
 };
-export {};

package/dist/x-conversations/index.js

@@ -1,2 +1,38 @@
-import { t as useXConversations } from "../x-conversations-BrKWhj5r.js";
+import resolveMaybeRef from "../_util/resolveMaybeRef.js";
+import { ConversationStore } from "./store.js";
+import { isRef, onScopeDispose, ref, shallowRef, watch } from "vue";
+//#region src/x-conversations/index.ts
+function useXConversations(config) {
+	const store = new ConversationStore(resolveMaybeRef(config?.defaultConversations) || [], resolveMaybeRef(config?.defaultActiveConversationKey) || "");
+	const conversations = shallowRef(store.getSnapshot());
+	const activeConversationKey = ref(store.getActiveConversationKey());
+	const syncStore = () => {
+		conversations.value = store.getSnapshot();
+		activeConversationKey.value = store.getActiveConversationKey();
+	};
+	const unsubscribe = store.subscribe(syncStore);
+	syncStore();
+	if (config?.defaultConversations && isRef(config.defaultConversations)) watch(config.defaultConversations, (list) => {
+		store.setConversations(list || []);
+	}, { deep: true });
+	if (config?.defaultActiveConversationKey && isRef(config.defaultActiveConversationKey)) watch(config.defaultActiveConversationKey, (key) => {
+		if (typeof key === "string") store.setActiveConversationKey(key);
+	});
+	onScopeDispose(() => {
+		unsubscribe();
+		store.destroy();
+	});
+	return {
+		conversations,
+		activeConversationKey,
+		setActiveConversationKey: store.setActiveConversationKey,
+		addConversation: store.addConversation,
+		removeConversation: store.removeConversation,
+		setConversation: store.setConversation,
+		getConversation: store.getConversation,
+		setConversations: store.setConversations,
+		getMessages: store.getMessages
+	};
+}
+//#endregion
 export { useXConversations as default };

package/dist/{x-conversations-BrKWhj5r.js → x-conversations/store.js}

@@ -1,5 +1,4 @@
-import { n as chatMessagesStoreHelper } from "./store-C1diHqNH.js";
-import { onScopeDispose, ref, shallowRef } from "vue";
+import { chatMessagesStoreHelper } from "../x-chat/store.js";
 //#region src/x-conversations/store.ts
 var conversationStoreHelper = {
 	_allConversationStores: /* @__PURE__ */ new Map(),
@@ -91,32 +90,4 @@ var ConversationStore = class {
 	};
 };
 //#endregion
-//#region src/x-conversations/index.ts
-function useXConversations(config) {
-	const store = new ConversationStore(config?.defaultConversations || [], config?.defaultActiveConversationKey || "");
-	const conversations = shallowRef(store.getSnapshot());
-	const activeConversationKey = ref(store.getActiveConversationKey());
-	const syncStore = () => {
-		conversations.value = store.getSnapshot();
-		activeConversationKey.value = store.getActiveConversationKey();
-	};
-	const unsubscribe = store.subscribe(syncStore);
-	syncStore();
-	onScopeDispose(() => {
-		unsubscribe();
-		store.destroy();
-	});
-	return {
-		conversations,
-		activeConversationKey,
-		setActiveConversationKey: store.setActiveConversationKey,
-		addConversation: store.addConversation,
-		removeConversation: store.removeConversation,
-		setConversation: store.setConversation,
-		getConversation: store.getConversation,
-		setConversations: store.setConversations,
-		getMessages: store.getMessages
-	};
-}
-//#endregion
-export { useXConversations as t };
+export { ConversationStore, conversationStoreHelper };

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

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

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

@@ -0,0 +1,90 @@
+import XRequest from "../index.js";
+import { describe, it } from "../../node_modules/vitest/dist/@vitest/runner/chunk-artifact.js";
+import { globalExpect, vi } from "../../node_modules/vitest/dist/chunks/test.CBQUpOM3.js";
+import { ref } from "vue";
+//#region src/x-request/__tests__/index.test.ts
+describe("XRequest", () => {
+	it("uses reactive baseURL / params / headers refs on each run", async () => {
+		const baseURL = ref("https://example.com/api/v1");
+		const params = ref({ a: 1 });
+		const headers = ref({ Authorization: "Bearer token-1" });
+		const fetchMock = vi.fn(async (_url, _options) => {
+			return new Response(JSON.stringify({ success: true }), {
+				status: 200,
+				headers: { "content-type": "application/json" }
+			});
+		});
+		const request = XRequest(baseURL, {
+			manual: true,
+			params,
+			headers,
+			fetch: fetchMock
+		});
+		request.run({ b: 2 });
+		await request.asyncHandler;
+		globalExpect(fetchMock).toHaveBeenCalledTimes(1);
+		const firstCall = fetchMock.mock.calls[0];
+		const firstUrl = firstCall[0];
+		const firstOptions = firstCall[1];
+		globalExpect(firstUrl).toBe("https://example.com/api/v1");
+		globalExpect(JSON.parse(firstOptions.body)).toEqual({
+			a: 1,
+			b: 2
+		});
+		globalExpect(firstOptions.headers.Authorization).toBe("Bearer token-1");
+		baseURL.value = "https://example.com/api/v2";
+		params.value = { a: 3 };
+		headers.value = { Authorization: "Bearer token-2" };
+		request.run({ b: 4 });
+		await request.asyncHandler;
+		globalExpect(fetchMock).toHaveBeenCalledTimes(2);
+		const secondCall = fetchMock.mock.calls[1];
+		const secondUrl = secondCall[0];
+		const secondOptions = secondCall[1];
+		globalExpect(secondUrl).toBe("https://example.com/api/v2");
+		globalExpect(JSON.parse(secondOptions.body)).toEqual({
+			a: 3,
+			b: 4
+		});
+		globalExpect(secondOptions.headers.Authorization).toBe("Bearer token-2");
+	});
+	it("tracks reactive manual option", () => {
+		const manual = ref(true);
+		const request = XRequest("https://example.com/manual", {
+			manual,
+			fetch: vi.fn()
+		});
+		globalExpect(request.manual).toBe(true);
+		manual.value = false;
+		globalExpect(request.manual).toBe(false);
+		manual.value = true;
+		globalExpect(request.manual).toBe(true);
+	});
+	it("supports plain middlewares object", async () => {
+		const onRequest = vi.fn(async (baseURL, options) => {
+			return [`${baseURL.toString()}?mw=1`, options];
+		});
+		const onResponse = vi.fn(async (response) => response);
+		const fetchMock = vi.fn(async (_url) => {
+			return new Response(JSON.stringify({ success: true }), {
+				status: 200,
+				headers: { "content-type": "application/json" }
+			});
+		});
+		const request = XRequest("https://example.com/middlewares", {
+			manual: true,
+			fetch: fetchMock,
+			middlewares: {
+				onRequest,
+				onResponse
+			}
+		});
+		request.run();
+		await request.asyncHandler;
+		globalExpect(onRequest).toHaveBeenCalledTimes(1);
+		globalExpect(onResponse).toHaveBeenCalledTimes(1);
+		globalExpect(fetchMock).toHaveBeenCalledTimes(1);
+		globalExpect(fetchMock.mock.calls[0]?.[0]).toBe("https://example.com/middlewares?mw=1");
+	});
+});
+//#endregion

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

@@ -1,3 +1,4 @@
+import { MaybeRef } from 'vue';
 import { AnyObject } from '../_util/types';
 import { MessageInfo, SimpleType } from '../x-chat';
 import { SSEOutput, XStreamOptions } from '../x-stream';
@@ -23,30 +24,49 @@ export interface XRequestOptions<Input = AnyObject, Output = SSEOutput, ChatMess
     retryInterval?: number;
     retryTimes?: number;
 }
-export type XRequestGlobalOptions<Input, Output> = Pick<XRequestOptions<Input, Output>, "headers" | "timeout" | "streamTimeout" | "middlewares" | "fetch" | "transformStream" | "manual">;
-export type XRequestFunction<Input = AnyObject, Output = SSEOutput> = (baseURL: string, options?: XRequestOptions<Input, Output>) => XRequestClass<Input, Output>;
+export type XRequestConfigOptions<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any> = Omit<XRequestOptions<Input, Output, ChatMessage>, "callbacks" | "params" | "headers" | "timeout" | "streamTimeout" | "fetch" | "middlewares" | "transformStream" | "streamSeparator" | "partSeparator" | "kvSeparator" | "manual" | "retryInterval" | "retryTimes"> & {
+    callbacks?: XRequestCallbacks<Output, ChatMessage>;
+    params?: MaybeRef<Partial<Input>>;
+    headers?: MaybeRef<Record<string, string>>;
+    timeout?: MaybeRef<number>;
+    streamTimeout?: MaybeRef<number>;
+    fetch?: (baseURL: Parameters<typeof fetch>[0], options: XRequestOptions<Input, Output>) => Promise<Response>;
+    middlewares?: XFetchMiddlewares<Input, Output>;
+    transformStream?: XStreamOptions<Output>["transformStream"] | ((baseURL: string, responseHeaders: Headers) => XStreamOptions<Output>["transformStream"]);
+    streamSeparator?: MaybeRef<string>;
+    partSeparator?: MaybeRef<string>;
+    kvSeparator?: MaybeRef<string>;
+    manual?: MaybeRef<boolean>;
+    retryInterval?: MaybeRef<number>;
+    retryTimes?: MaybeRef<number>;
+};
+export type XRequestGlobalOptions<Input, Output> = Pick<XRequestConfigOptions<Input, Output>, "headers" | "timeout" | "streamTimeout" | "middlewares" | "fetch" | "transformStream" | "manual">;
+export type XRequestFunction<Input = AnyObject, Output = SSEOutput> = (baseURL: MaybeRef<string>, options?: XRequestConfigOptions<Input, Output>) => XRequestClass<Input, Output>;
+export interface XRequestReactiveState {
+    isTimeout: boolean;
+    isStreamTimeout: boolean;
+    isRequesting: boolean;
+}
 export declare function setXRequestGlobalOptions<Input, Output>(options: XRequestGlobalOptions<Input, Output>): void;
 export declare abstract class AbstractXRequestClass<Input, Output, ChatMessage extends SimpleType = any> {
-    baseURL: string;
-    options: XRequestOptions<Input, Output, ChatMessage>;
-    constructor(baseURL: string, options?: XRequestOptions<Input, Output, ChatMessage>);
+    baseURL: MaybeRef<string>;
+    options: XRequestConfigOptions<Input, Output, ChatMessage>;
+    constructor(baseURL: MaybeRef<string>, options?: XRequestConfigOptions<Input, Output, ChatMessage>);
     abstract get asyncHandler(): Promise<any>;
     abstract get isTimeout(): boolean;
     abstract get isStreamTimeout(): boolean;
     abstract get isRequesting(): boolean;
     abstract get manual(): boolean;
+    abstract get state(): Readonly<XRequestReactiveState>;
     abstract run(params?: Input): void;
     abstract abort(): void;
 }
 export declare class XRequestClass<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any> extends AbstractXRequestClass<Input, Output, ChatMessage> {
     private _asyncHandler;
     private timeoutHandler;
-    private _isTimeout;
     private streamTimeoutHandler;
-    private _isStreamTimeout;
     private abortController;
-    private _isRequesting;
-    private _manual;
+    private _state;
     private lastManualParams?;
     private retryTimes;
     private retryTimer;
@@ -58,7 +78,12 @@ export declare class XRequestClass<Input = AnyObject, Output = SSEOutput, ChatMe
     private set isStreamTimeout(value);
     get isRequesting(): boolean;
     get manual(): boolean;
-    constructor(baseURL: string, options?: XRequestOptions<Input, Output, ChatMessage>);
+    get state(): {
+        readonly isTimeout: boolean;
+        readonly isStreamTimeout: boolean;
+        readonly isRequesting: boolean;
+    };
+    constructor(baseURL: MaybeRef<string>, options?: XRequestConfigOptions<Input, Output, ChatMessage>);
     run(params?: Input): boolean;
     abort(): void;
     private init;
@@ -70,5 +95,5 @@ export declare class XRequestClass<Input = AnyObject, Output = SSEOutput, ChatMe
     private jsonResponseHandler;
     private resetRetry;
 }
-declare function XRequest<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any>(baseURL: string, options?: XRequestOptions<Input, Output, ChatMessage>): AbstractXRequestClass<Input, Output, ChatMessage>;
+declare function XRequest<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any>(baseURL: MaybeRef<string>, options?: XRequestConfigOptions<Input, Output, ChatMessage>): AbstractXRequestClass<Input, Output, ChatMessage>;
 export default XRequest;

package/dist/x-request/index.js

@@ -1,2 +1,247 @@
-import { i as setXRequestGlobalOptions, n as XRequest, r as XRequestClass, t as AbstractXRequestClass } from "../x-request-BSFGaKND.js";
+import resolveMaybeRef from "../_util/resolveMaybeRef.js";
+import XStream from "../x-stream/index.js";
+import XFetch from "./x-fetch.js";
+import { reactive, readonly } from "vue";
+//#region src/x-request/index.ts
+var globalOptions = {
+	manual: false,
+	headers: { "Content-Type": "application/json" }
+};
+function setXRequestGlobalOptions(options) {
+	Object.assign(globalOptions, options);
+}
+var LastEventId = "Last-Event-ID";
+var AbstractXRequestClass = class {
+	baseURL;
+	options;
+	constructor(baseURL, options) {
+		const resolvedBaseURL = resolveMaybeRef(baseURL);
+		if (!resolvedBaseURL || typeof resolvedBaseURL !== "string") throw new Error("The baseURL is not valid!");
+		this.baseURL = baseURL;
+		this.options = options || {};
+	}
+};
+var XRequestClass = class extends AbstractXRequestClass {
+	_asyncHandler;
+	timeoutHandler;
+	streamTimeoutHandler;
+	abortController;
+	_state = reactive({
+		isTimeout: false,
+		isStreamTimeout: false,
+		isRequesting: false
+	});
+	lastManualParams;
+	retryTimes = 0;
+	retryTimer;
+	lastEventId = void 0;
+	get asyncHandler() {
+		return this._asyncHandler;
+	}
+	get isTimeout() {
+		return this._state.isTimeout;
+	}
+	set isTimeout(value) {
+		this._state.isTimeout = value;
+	}
+	get isStreamTimeout() {
+		return this._state.isStreamTimeout;
+	}
+	set isStreamTimeout(value) {
+		this._state.isStreamTimeout = value;
+	}
+	get isRequesting() {
+		return this._state.isRequesting;
+	}
+	get manual() {
+		const localManual = resolveMaybeRef(this.options.manual);
+		if (typeof localManual === "boolean") return localManual;
+		const globalManual = resolveMaybeRef(globalOptions.manual);
+		if (typeof globalManual === "boolean") return globalManual;
+		return false;
+	}
+	get state() {
+		return readonly(this._state);
+	}
+	constructor(baseURL, options) {
+		super(baseURL, options);
+		if (!this.manual) this.init();
+	}
+	run(params) {
+		if (this.manual) {
+			this.resetRetry();
+			this.lastManualParams = params;
+			this.init(params);
+			return true;
+		}
+		console.warn("The request is not manual, so it cannot be run!");
+		return false;
+	}
+	abort() {
+		clearTimeout(this.timeoutHandler);
+		clearTimeout(this.streamTimeoutHandler);
+		this.abortController.abort();
+	}
+	init(extraParams, extraHeaders) {
+		const currentBaseURL = resolveMaybeRef(this.baseURL);
+		if (!currentBaseURL || typeof currentBaseURL !== "string") throw new Error("The baseURL is not valid!");
+		this.abortController = new AbortController();
+		this.isTimeout = false;
+		this.isStreamTimeout = false;
+		const { callbacks: sourceCallbacks, params: sourceParams, headers: sourceHeaders, transformStream: sourceTransformStream, fetch: sourceFetch, timeout: sourceTimeout, streamTimeout: sourceStreamTimeout, middlewares: sourceMiddlewares, streamSeparator: sourceStreamSeparator, partSeparator: sourcePartSeparator, kvSeparator: sourceKvSeparator, manual: _sourceManual, retryInterval: sourceRetryInterval, retryTimes: sourceRetryTimes, ...otherOptions } = this.options;
+		const callbacks = sourceCallbacks;
+		const params = resolveMaybeRef(sourceParams);
+		const headers = resolveMaybeRef(sourceHeaders) || {};
+		const transformStream = sourceTransformStream;
+		const fetch = sourceFetch;
+		const timeout = resolveMaybeRef(sourceTimeout);
+		const streamTimeout = resolveMaybeRef(sourceStreamTimeout);
+		const middlewares = sourceMiddlewares;
+		const streamSeparator = resolveMaybeRef(sourceStreamSeparator);
+		const partSeparator = resolveMaybeRef(sourcePartSeparator);
+		const kvSeparator = resolveMaybeRef(sourceKvSeparator);
+		const retryInterval = resolveMaybeRef(sourceRetryInterval);
+		const retryTimes = resolveMaybeRef(sourceRetryTimes);
+		const globalHeaders = resolveMaybeRef(globalOptions.headers) || {};
+		const margeHeaders = Object.assign({}, globalHeaders, headers, extraHeaders || {});
+		const requestInit = {
+			...otherOptions,
+			method: "POST",
+			body: JSON.stringify({
+				...params,
+				...extraParams
+			}),
+			params: {
+				...params,
+				...extraParams
+			},
+			headers: margeHeaders,
+			signal: this.abortController.signal,
+			middlewares
+		};
+		if (timeout && timeout > 0) this.timeoutHandler = setTimeout(() => {
+			this.isTimeout = true;
+			this.finishRequest();
+			callbacks?.onError?.(/* @__PURE__ */ new Error("TimeoutError"));
+		}, timeout);
+		this.startRequest();
+		this._asyncHandler = XFetch(currentBaseURL, {
+			fetch,
+			...requestInit
+		}).then(async (response) => {
+			clearTimeout(this.timeoutHandler);
+			if (this.isTimeout) return;
+			if (transformStream) {
+				let transformer = transformStream;
+				if (typeof transformStream === "function") transformer = transformStream(currentBaseURL, response.headers);
+				await this.customResponseHandler(response, callbacks, transformer, streamTimeout, streamSeparator, partSeparator, kvSeparator);
+				return;
+			}
+			const contentType = response.headers.get("content-type") || "";
+			switch (contentType.split(";")[0].trim()) {
+				case "text/event-stream":
+					await this.sseResponseHandler(response, callbacks, streamTimeout, streamSeparator, partSeparator, kvSeparator);
+					break;
+				case "application/json":
+					await this.jsonResponseHandler(response, callbacks);
+					break;
+				default: throw new Error(`The response content-type: ${contentType} is not support!`);
+			}
+		}).catch((error) => {
+			clearTimeout(this.timeoutHandler);
+			this.finishRequest();
+			const err = error instanceof Error || error instanceof DOMException ? error : /* @__PURE__ */ new Error("Unknown error!");
+			const returnOfOnError = callbacks?.onError?.(err);
+			if (err.name !== "AbortError") {
+				const actualRetryInterval = typeof returnOfOnError === "number" ? returnOfOnError : retryInterval;
+				if (actualRetryInterval && actualRetryInterval > 0) {
+					if (typeof retryTimes === "number" && this.retryTimes >= retryTimes) return;
+					clearTimeout(this.retryTimer);
+					this.retryTimer = setTimeout(() => {
+						const extraHeaders = {};
+						if (typeof this.lastEventId !== "undefined") extraHeaders[LastEventId] = this.lastEventId;
+						this.init(this.lastManualParams, extraHeaders);
+					}, actualRetryInterval);
+					this.retryTimes = this.retryTimes + 1;
+				}
+			}
+		});
+	}
+	startRequest() {
+		this._state.isRequesting = true;
+	}
+	finishRequest() {
+		this._state.isRequesting = false;
+	}
+	customResponseHandler = async (response, callbacks, transformStream, streamTimeout, streamSeparator, partSeparator, kvSeparator) => {
+		const stream = XStream({
+			readableStream: response.body,
+			transformStream,
+			streamSeparator,
+			partSeparator,
+			kvSeparator
+		});
+		await this.processStream(stream, response, callbacks, streamTimeout);
+	};
+	sseResponseHandler = async (response, callbacks, streamTimeout, streamSeparator, partSeparator, kvSeparator) => {
+		const stream = XStream({
+			readableStream: response.body,
+			streamSeparator,
+			partSeparator,
+			kvSeparator
+		});
+		await this.processStream(stream, response, callbacks, streamTimeout);
+	};
+	async processStream(stream, response, callbacks, streamTimeout) {
+		const chunks = [];
+		const iterator = stream[Symbol.asyncIterator]();
+		let result;
+		do {
+			if (streamTimeout) this.streamTimeoutHandler = setTimeout(() => {
+				this.isStreamTimeout = true;
+				this.finishRequest();
+				callbacks?.onError?.(/* @__PURE__ */ new Error("StreamTimeoutError"), void 0, response.headers);
+			}, streamTimeout);
+			result = await iterator.next();
+			clearTimeout(this.streamTimeoutHandler);
+			if (this.isStreamTimeout) break;
+			if (result.value) {
+				chunks.push(result.value);
+				callbacks?.onUpdate?.(result.value, response.headers);
+				if (typeof result?.value?.id !== "undefined") this.lastEventId = result.value.id;
+			}
+		} while (!result.done);
+		if (streamTimeout) {
+			clearTimeout(this.streamTimeoutHandler);
+			if (this.isStreamTimeout) {
+				this.finishRequest();
+				return;
+			}
+		}
+		this.finishRequest();
+		callbacks?.onSuccess?.(chunks, response.headers);
+	}
+	jsonResponseHandler = async (response, callbacks) => {
+		const chunk = await response.json();
+		if (chunk?.success === false) {
+			this.finishRequest();
+			const error = new Error(chunk.message || "System error");
+			error.name = chunk.name || "SystemError";
+			callbacks?.onError?.(error, chunk, response.headers);
+		} else {
+			callbacks?.onUpdate?.(chunk, response.headers);
+			this.finishRequest();
+			callbacks?.onSuccess?.([chunk], response.headers);
+		}
+	};
+	resetRetry() {
+		clearTimeout(this.retryTimer);
+		this.retryTimes = 0;
+		this.lastEventId = void 0;
+	}
+};
+function XRequest(baseURL, options) {
+	return new XRequestClass(baseURL, options);
+}
+//#endregion
 export { AbstractXRequestClass, XRequestClass, XRequest as default, setXRequestGlobalOptions };

package/dist/x-request/x-fetch.js

@@ -0,0 +1,18 @@
+//#region src/x-request/x-fetch.ts
+var XFetch = async (baseURL, options) => {
+	const { fetch: fetchFn = globalThis.fetch, middlewares = {}, ...requestInit } = options;
+	if (typeof fetchFn !== "function") throw new Error("The options.fetch must be a typeof fetch function!");
+	let fetchArgs = [baseURL, requestInit];
+	if (typeof middlewares.onRequest === "function") fetchArgs = await middlewares.onRequest(...fetchArgs);
+	let response = await fetchFn(...fetchArgs);
+	if (typeof middlewares.onResponse === "function") {
+		const modifiedResponse = await middlewares.onResponse(response);
+		if (!(modifiedResponse instanceof Response)) throw new Error("The options.onResponse must return a Response instance!");
+		response = modifiedResponse;
+	}
+	if (!response.ok) throw new Error(`Fetch failed with status ${response.status}`);
+	if (!response.body) throw new Error("The response body is empty.");
+	return response;
+};
+//#endregion
+export { XFetch as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antdv-next/x-sdk",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "files": [
     "dist"
   ],