@antdv-next/x-sdk 0.0.1 → 0.0.3

package/dist/x-request-BSFGaKND.js

@@ -1,234 +0,0 @@
-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 };