@zayne-labs/callapi 1.12.3 → 1.12.5

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as getCurrentRouteSchemaKeyAndMainInitURL, B as isReadableStream, L as isArray, M as handleSchemaValidation, N as HTTPError, R as isBoolean, V as isString, a as getBody, c as getMethod, d as splitConfig, f as waitFor, h as isHTTPErrorInstance, i as createTimeoutSignal, j as handleConfigValidation, k as getFullAndNormalizedURL, l as getResolvedHeaders, o as getFetchImpl, r as createCombinedSignal, s as getHeaders, t as extraOptionDefaults, u as omitKeys, v as isValidationErrorInstance, z as isFunction } from "./defaults-S9x_Ra9q.js";
+import { A as getCurrentRouteSchemaKeyAndMainInitURL, B as isString, L as isArray, M as handleSchemaValidation, N as HTTPError, R as isBoolean, a as getBody, c as getMethod, d as splitConfig, f as waitFor, h as isHTTPErrorInstance, i as createTimeoutSignal, j as handleConfigValidation, k as getFullAndNormalizedURL, l as getResolvedHeaders, o as getFetchImpl, r as createCombinedSignal, s as getHeaders, t as extraOptionDefaults, u as omitKeys, v as isValidationErrorInstance, z as isFunction } from "./defaults-D0QJmGE5.js";
 //#region src/result.ts
 const getResponseType = (response, responseParser) => ({
 	arrayBuffer: () => response.arrayBuffer(),
@@ -159,104 +159,128 @@ const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
 //#endregion
 //#region src/stream.ts
 const createProgressEvent = (options) => {
-	const { chunk, totalBytes, transferredBytes } = options;
+	const { chunk, isDone, totalBytes, transferredBytes } = options;
+	let percentage = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+	if (percentage >= 1) percentage = 1 - Number.EPSILON;
 	return {
 		chunk,
-		progress: Math.round(transferredBytes / totalBytes * 100) || 0,
+		progress: (isDone ? 1 : percentage) * 100,
 		totalBytes,
 		transferredBytes
 	};
 };
-const calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
-	let totalBytes = existingTotalBytes;
-	if (!requestBody) return totalBytes;
-	for await (const chunk of requestBody) totalBytes += chunk.byteLength;
-	return totalBytes;
+const textEncoder = new TextEncoder();
+const estimateBodySize = (body) => {
+	if (!body) return 0;
+	if (body instanceof ReadableStream) return 0;
+	if (body instanceof FormData) {
+		let size = 0;
+		for (const [key, value] of body) {
+			size += 40;
+			size += textEncoder.encode(`Content-Disposition: form-data; name="${key}"`).byteLength;
+			size += isString(value) ? textEncoder.encode(value).byteLength : value.size;
+		}
+		return size;
+	}
+	if (body instanceof Blob) return body.size;
+	if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return body.byteLength;
+	if (isString(body) || body instanceof URLSearchParams) return textEncoder.encode(String(body)).byteLength;
+	return 0;
 };
-const toStreamableRequest = async (context) => {
+const createTrackedStream = (streamOptions) => {
+	const { initialTotalBytes, onStream, streamBody } = streamOptions;
+	let totalBytes = initialTotalBytes;
+	let transferredBytes = 0;
+	const reportProgress = async (progressOptions) => {
+		const { chunk, isDone } = progressOptions;
+		if (isDone) {
+			await onStream(createProgressEvent({
+				chunk: null,
+				isDone: true,
+				totalBytes,
+				transferredBytes
+			}));
+			return;
+		}
+		transferredBytes += chunk.byteLength;
+		totalBytes = Math.max(totalBytes, transferredBytes);
+		await onStream(createProgressEvent({
+			chunk,
+			totalBytes,
+			transferredBytes
+		}));
+	};
+	return streamBody.pipeThrough(new TransformStream({
+		flush: async () => {
+			await reportProgress({
+				chunk: null,
+				isDone: true
+			});
+		},
+		start: async () => {
+			await reportProgress({ chunk: new Uint8Array() });
+		},
+		transform: async (chunk, controller) => {
+			controller.enqueue(chunk);
+			await reportProgress({ chunk });
+		}
+	}));
+};
+const toStreamableRequest = (context) => {
 	const { baseConfig, config, options, request } = context;
-	if (!options.onRequestStream || !isReadableStream(request.body)) return request;
+	if (!options.onRequestStream || !request.body) return request;
 	const requestInstance = new Request(options.fullURL, {
 		...request,
 		duplex: "half"
 	});
 	const contentLength = requestInstance.headers.get("content-length");
-	let totalBytes = Number(contentLength ?? 0);
-	if (!contentLength && options.forcefullyCalculateRequestStreamSize) totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
-	let transferredBytes = 0;
-	const stream = new ReadableStream({ start: async (controller) => {
-		const body = requestInstance.body;
-		if (!body) return;
-		const requestStreamContext = {
-			baseConfig,
-			config,
-			event: createProgressEvent({
-				chunk: new Uint8Array(),
-				totalBytes,
-				transferredBytes
-			}),
-			options,
-			request,
-			requestInstance
-		};
-		await executeHooks(options.onRequestStream?.(requestStreamContext));
-		for await (const chunk of body) {
-			transferredBytes += chunk.byteLength;
-			totalBytes = Math.max(totalBytes, transferredBytes);
+	const initialTotalBytes = contentLength ? Math.max(0, Number(contentLength) || 0) : estimateBodySize(config.body ?? request.body);
+	const streamBody = requestInstance.body;
+	if (!streamBody) return requestInstance;
+	const requestStreamContext = {
+		baseConfig,
+		config,
+		options,
+		request,
+		requestInstance
+	};
+	const trackedStream = createTrackedStream({
+		initialTotalBytes,
+		onStream: async (event) => {
 			await executeHooks(options.onRequestStream?.({
 				...requestStreamContext,
-				event: createProgressEvent({
-					chunk,
-					totalBytes,
-					transferredBytes
-				})
+				event
 			}));
-			controller.enqueue(chunk);
-		}
-		controller.close();
-	} });
+		},
+		streamBody
+	});
 	return new Request(requestInstance, {
-		body: stream,
+		body: trackedStream,
 		duplex: "half"
 	});
 };
 const toStreamableResponse = (context) => {
 	const { baseConfig, config, options, request, response } = context;
-	if (!options.onResponseStream || !response.body) return response;
-	const contentLength = response.headers.get("content-length");
-	let totalBytes = Number(contentLength ?? 0);
-	let transferredBytes = 0;
-	const stream = new ReadableStream({ start: async (controller) => {
-		const body = response.body;
-		if (!body) return;
-		const responseStreamContext = {
-			baseConfig,
-			config,
-			event: createProgressEvent({
-				chunk: new Uint8Array(),
-				totalBytes,
-				transferredBytes
-			}),
-			options,
-			request,
-			response
-		};
-		await executeHooks(options.onResponseStream?.(responseStreamContext));
-		for await (const chunk of body) {
-			transferredBytes += chunk.byteLength;
-			totalBytes = Math.max(totalBytes, transferredBytes);
+	if (!options.onResponseStream || !response.body || response.status === 204) return response;
+	const initialTotalBytes = Math.max(0, Number(response.headers.get("content-length")) || 0);
+	const streamBody = response.body;
+	const responseStreamContext = {
+		baseConfig,
+		config,
+		options,
+		request,
+		response
+	};
+	const stream = createTrackedStream({
+		initialTotalBytes,
+		onStream: async (event) => {
 			await executeHooks(options.onResponseStream?.({
 				...responseStreamContext,
-				event: createProgressEvent({
-					chunk,
-					totalBytes,
-					transferredBytes
-				})
+				event
 			}));
-			controller.enqueue(chunk);
-		}
-		controller.close();
-	} });
+		},
+		streamBody
+	});
 	return new Response(stream, response);
 };
 //#endregion
@@ -326,20 +350,19 @@ const createDedupeStrategy = async (context) => {
 	const handleRequestDeferStrategy = async (deferContext) => {
 		const { fetchApi, options: localOptions, request: localRequest } = deferContext;
 		const shouldUsePromiseFromCache = prevRequestInfo && resolvedDedupeStrategy === "defer";
-		const streamableContext = {
+		const streamContext = {
 			baseConfig,
 			config,
 			options: localOptions,
 			request: localRequest
 		};
-		const streamableRequest = await toStreamableRequest(streamableContext);
-		const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : fetchApi(localOptions.fullURL, streamableRequest);
+		const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : fetchApi(localOptions.fullURL, toStreamableRequest(streamContext));
 		$RequestInfoCache?.set({
 			controller: newFetchController,
 			responsePromise
 		});
 		return toStreamableResponse({
-			...streamableContext,
+			...streamContext,
 			response: await responsePromise
 		});
 	};
@@ -586,16 +609,15 @@ const createRetryManager = (ctx) => {
 };
 //#endregion
 //#region src/createFetchClient.ts
-const getTimeoutSignal = "timeout" in AbortSignal ? createTimeoutSignal : import("./timeoutSignal-B9V7QESI.js").then((module) => module.createTimeoutSignal);
-const getCombinedSignal = "any" in AbortSignal ? createCombinedSignal : import("./combinedSignal-ChYtee_L.js").then((module) => module.createCombinedSignal);
 const $GlobalRequestInfoCache = /* @__PURE__ */ new Map();
 const createFetchClientWithContext = () => {
 	const createFetchClient = (initBaseConfig = {}) => {
 		const $LocalRequestInfoCache = /* @__PURE__ */ new Map();
 		const callApi = async (initURL, initConfig = {}) => {
 			const [fetchOptions, extraOptions] = splitConfig(initConfig);
+			const initURLString = initURL.toString();
 			const baseConfig = isFunction(initBaseConfig) ? initBaseConfig({
-				initURL: initURL.toString(),
+				initURL: initURLString,
 				options: extraOptions,
 				request: fetchOptions
 			}) : initBaseConfig;
@@ -616,7 +638,7 @@ const createFetchClientWithContext = () => {
 			const initURLResult = getCurrentRouteSchemaKeyAndMainInitURL({
 				baseExtraOptions: baseConfig,
 				extraOptions: config,
-				initURL: initURL.toString()
+				initURL: initURLString
 			});
 			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequest } = await initializePlugins({
 				baseConfig,
@@ -659,8 +681,7 @@ const createFetchClientWithContext = () => {
 			});
 			Object.assign(options, refetchFnResult);
 			const newFetchController = new AbortController();
-			const timeoutSignal = (await getTimeoutSignal)(options.timeout);
-			const combinedSignal = (await getCombinedSignal)(timeoutSignal, resolvedRequest.signal, newFetchController.signal);
+			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequest.signal, newFetchController.signal);
 			const request = {
 				...resolvedRequest,
 				signal: combinedSignal