@antdv-next/x-sdk 0.0.1

package/dist/x-request-BSFGaKND.js

@@ -0,0 +1,234 @@
+import XStream from "./x-stream/index.js";
+//#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
+//#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) {
+		if (!baseURL || typeof baseURL !== "string") throw new Error("The baseURL is not valid!");
+		this.baseURL = baseURL;
+		this.options = options || {};
+	}
+};
+var XRequestClass = class extends AbstractXRequestClass {
+	_asyncHandler;
+	timeoutHandler;
+	_isTimeout = false;
+	streamTimeoutHandler;
+	_isStreamTimeout = false;
+	abortController;
+	_isRequesting = false;
+	_manual = false;
+	lastManualParams;
+	retryTimes = 0;
+	retryTimer;
+	lastEventId = void 0;
+	get asyncHandler() {
+		return this._asyncHandler;
+	}
+	get isTimeout() {
+		return this._isTimeout;
+	}
+	set isTimeout(value) {
+		this._isTimeout = value;
+	}
+	get isStreamTimeout() {
+		return this._isStreamTimeout;
+	}
+	set isStreamTimeout(value) {
+		this._isStreamTimeout = value;
+	}
+	get isRequesting() {
+		return this._isRequesting;
+	}
+	get manual() {
+		return this._manual;
+	}
+	constructor(baseURL, options) {
+		super(baseURL, options);
+		this._manual = options?.manual || false;
+		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) {
+		this.abortController = new AbortController();
+		const { callbacks, params, headers = {}, transformStream, fetch, timeout, streamTimeout, middlewares, streamSeparator, partSeparator, kvSeparator, ...otherOptions } = this.options;
+		const margeHeaders = Object.assign({}, globalOptions.headers || {}, 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 = window.setTimeout(() => {
+			this.isTimeout = true;
+			this.finishRequest();
+			callbacks?.onError?.(/* @__PURE__ */ new Error("TimeoutError"));
+		}, timeout);
+		this.startRequest();
+		this._asyncHandler = XFetch(this.baseURL, {
+			fetch,
+			...requestInit
+		}).then(async (response) => {
+			clearTimeout(this.timeoutHandler);
+			if (this.isTimeout) return;
+			if (transformStream) {
+				let transformer = transformStream;
+				if (typeof transformStream === "function") transformer = transformStream(this.baseURL, 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 retryInterval = typeof returnOfOnError === "number" ? returnOfOnError : this.options.retryInterval;
+				if (retryInterval && retryInterval > 0) {
+					if (typeof this.options.retryTimes === "number" && this.retryTimes >= this.options.retryTimes) return;
+					clearTimeout(this.retryTimer);
+					this.retryTimer = setTimeout(() => {
+						const extraHeaders = {};
+						if (typeof this.lastEventId !== "undefined") extraHeaders[LastEventId] = this.lastEventId;
+						this.init(this.lastManualParams, extraHeaders);
+					}, retryInterval);
+					this.retryTimes = this.retryTimes + 1;
+				}
+			}
+		});
+	}
+	startRequest() {
+		this._isRequesting = true;
+	}
+	finishRequest() {
+		this._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 = window.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) {
+			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 { setXRequestGlobalOptions as i, XRequest as n, XRequestClass as r, AbstractXRequestClass as t };

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

@@ -0,0 +1,49 @@
+/**
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#fields
+ */
+export type SSEFields = "data" | "event" | "id" | "retry";
+/**
+ * @example
+ * const sseObject = {
+ *    event: 'delta',
+ *    data: '{ key: "world!" }',
+ * };
+ */
+export type SSEOutput = Partial<Record<SSEFields, any>>;
+export interface JSONOutPut extends Partial<Record<SSEFields, any>> {
+    success: boolean;
+    message?: string;
+    name?: string;
+}
+export interface XStreamOptions<Output> {
+    /**
+     * @description Readable stream of binary data
+     * @link https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
+     */
+    readableStream: ReadableStream<Uint8Array>;
+    /**
+     * @description Support customizable transformStream to transform streams
+     * @default sseTransformStream
+     * @link https://developer.mozilla.org/en-US/docs/Web/API/TransformStream
+     */
+    transformStream?: TransformStream<string, Output>;
+    /**
+     * @description Separator for stream data parsing
+     */
+    streamSeparator?: string;
+    /**
+     * @description Separator for different parts within the stream
+     */
+    partSeparator?: string;
+    /**
+     * @description Separator for key-value pairs in the stream data
+     */
+    kvSeparator?: string;
+}
+export type XReadableStream<R = SSEOutput> = ReadableStream<R> & AsyncGenerator<R>;
+/**
+ * @description Transform Uint8Array binary stream to {@link SSEOutput} by default
+ * @warning The `XStream` only support the `utf-8` encoding. More encoding support maybe in the future.
+ */
+declare function XStream<Output = SSEOutput>(options: XStreamOptions<Output>): XReadableStream<Output>;
+export default XStream;

package/dist/x-stream/index.js

@@ -0,0 +1,114 @@
+//#region src/x-stream/index.ts
+/**
+* @description default separator for {@link splitStream}
+*/
+var DEFAULT_STREAM_SEPARATOR = "\n\n";
+/**
+* @description Default separator for {@link splitPart}
+* @example "event: delta\ndata: {\"key\": \"value\"}"
+*/
+var DEFAULT_PART_SEPARATOR = "\n";
+/**
+* @description Default separator for key value, A colon (`:`) is used to separate keys from values
+* @example "event: delta"
+*/
+var DEFAULT_KV_SEPARATOR = ":";
+/**
+* Check if a string is not empty or only contains whitespace characters
+*/
+var isValidString = (str) => (str ?? "").trim() !== "";
+/**
+* @description A TransformStream inst that splits a stream into parts based on {@link DEFAULT_STREAM_SEPARATOR}
+* @example
+*
+* `event: delta
+* data: { content: 'hello' }
+*
+* event: delta
+* data: { key: 'world!' }
+*
+* `
+*/
+function splitStream(streamSeparator = DEFAULT_STREAM_SEPARATOR) {
+	let buffer = "";
+	return new TransformStream({
+		transform(streamChunk, controller) {
+			buffer += streamChunk;
+			const parts = buffer.split(streamSeparator);
+			parts.slice(0, -1).forEach((part) => {
+				if (isValidString(part)) controller.enqueue(part);
+			});
+			buffer = parts[parts.length - 1];
+		},
+		flush(controller) {
+			if (isValidString(buffer)) controller.enqueue(buffer);
+		}
+	});
+}
+/**
+* @description A TransformStream inst that transforms a part string into {@link SSEOutput}
+* @example part string
+*
+* "event: delta\ndata: { key: 'world!' }\n"
+*
+* @link https://developer.mozilla.org/en-US/docs/Web/API/EventSource
+*
+* When handling responses with `Content-Type: text/event-stream`, the following standard practices are commonly observed:
+* - Double newline characters (`\n\n`) are used to separate individual events.
+* - Single newline characters (`\n`) are employed to separate line within an event.
+*/
+function splitPart(partSeparator = DEFAULT_PART_SEPARATOR, kvSeparator = DEFAULT_KV_SEPARATOR) {
+	return new TransformStream({ transform(partChunk, controller) {
+		const sseEvent = partChunk.split(partSeparator).reduce((acc, line) => {
+			const separatorIndex = line.indexOf(kvSeparator);
+			if (separatorIndex === -1) {
+				console.warn(`The key-value separator "${kvSeparator}" is not found in the sse line: ${line} !`);
+				return acc;
+			}
+			const key = line.slice(0, separatorIndex).trim();
+			if (!isValidString(key)) return acc;
+			const value = line.slice(separatorIndex + 1).trim();
+			return {
+				...acc,
+				[key]: value
+			};
+		}, {});
+		if (Object.keys(sseEvent).length === 0) return;
+		controller.enqueue(sseEvent);
+	} });
+}
+function createDecoderStream() {
+	if (typeof TextDecoderStream !== "undefined") return new TextDecoderStream();
+	const decoder = new TextDecoder("utf-8");
+	return new TransformStream({
+		transform(chunk, controller) {
+			controller.enqueue(decoder.decode(chunk, { stream: true }));
+		},
+		flush(controller) {
+			controller.enqueue(decoder.decode());
+		}
+	});
+}
+/**
+* @description Transform Uint8Array binary stream to {@link SSEOutput} by default
+* @warning The `XStream` only support the `utf-8` encoding. More encoding support maybe in the future.
+*/
+function XStream(options) {
+	const { readableStream, transformStream, streamSeparator, partSeparator, kvSeparator } = options;
+	if (!(readableStream instanceof ReadableStream)) throw new Error("The options.readableStream must be an instance of ReadableStream.");
+	const decoderStream = createDecoderStream();
+	const stream = transformStream ? readableStream.pipeThrough(decoderStream).pipeThrough(transformStream) : readableStream.pipeThrough(decoderStream).pipeThrough(splitStream(streamSeparator)).pipeThrough(splitPart(partSeparator, kvSeparator));
+	/** support async iterator */
+	stream[Symbol.asyncIterator] = async function* () {
+		const reader = this.getReader();
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (!value) continue;
+			yield value;
+		}
+	};
+	return stream;
+}
+//#endregion
+export { XStream as default };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@antdv-next/x-sdk",
+  "version": "0.0.1",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./chat-providers": {
+      "types": "./dist/chat-providers/index.d.ts",
+      "import": "./dist/chat-providers/index.js"
+    },
+    "./chat-providers/types/model": {
+      "types": "./dist/chat-providers/types/model.d.ts",
+      "import": "./dist/chat-providers/types/model.js"
+    },
+    "./x-chat": {
+      "types": "./dist/x-chat/index.d.ts",
+      "import": "./dist/x-chat/index.js"
+    },
+    "./x-conversations": {
+      "types": "./dist/x-conversations/index.d.ts",
+      "import": "./dist/x-conversations/index.js"
+    },
+    "./x-request": {
+      "types": "./dist/x-request/index.d.ts",
+      "import": "./dist/x-request/index.js"
+    },
+    "./x-stream": {
+      "types": "./dist/x-stream/index.d.ts",
+      "import": "./dist/x-stream/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "vue": ">=3.5.0"
+  },
+  "scripts": {
+    "type-check": "tsc --project tsconfig.json --noEmit",
+    "build": "vp build --config vite.build.config.ts"
+  }
+}