Add onUploadProgress option

source/core/Ky.ts

@@ -203,6 +203,24 @@
 			// The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
 			this.request = new globalThis.Request(new globalThis.Request(url, {...this.request}), this._options as RequestInit);
 		}
+
+		// Add onUploadProgress handling
+		if (this._options.onUploadProgress && typeof this._options.onUploadProgress === 'function') {
+			if (!supportsRequestStreams) {
+				throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
+			}
+
+			const originalBody = this.request.body;
+			if (originalBody) {
+				const totalBytes = this._getTotalBytes(originalBody);
+				this.request = new Request(this.request, {
+					body: this._wrapBodyWithUploadProgress(originalBody, totalBytes, this._options.onUploadProgress),
+					headers: this.request.headers,
+					method: this.request.method,
+					signal: this.request.signal,
+				});
+			}
+		}
 	}
 
 	protected _calculateRetryDelay(error: unknown) {
@@ -365,4 +383,66 @@
 			},
 		);
 	}
+
+	protected _getTotalBytes(body: globalThis.BodyInit): number {
+		if (body instanceof globalThis.Blob) {
+			return body.size;
+		}
+		if (body instanceof globalThis.ArrayBuffer) {
+			return body.byteLength;
+		}
+		if (typeof body === 'string') {
+			return new globalThis.TextEncoder().encode(body).length;
+		}
+		if (body instanceof URLSearchParams) {
+			return new globalThis.TextEncoder().encode(body.toString()).length;
+		}
+		if (body instanceof globalThis.FormData) {
+			// This is an approximation, as FormData size calculation is not straightforward
+			return Array.from(body.entries()).reduce((acc, [_, value]) => {
+				if (typeof value === 'string') {
+					return acc + new globalThis.TextEncoder().encode(value).length;
+				}
+				if (value instanceof Blob) {
+					return acc + value.size;
+				}
+				return acc;
+			}, 0);
+		}
+		if ('byteLength' in body) {
+			return (body as globalThis.ArrayBufferView).byteLength;
+		}
+		return 0; // Default case, unable to determine size
+	}
+
+	protected _wrapBodyWithUploadProgress(
+		body: BodyInit,
+		totalBytes: number,
+		onUploadProgress: (progress: { percent: number; transferredBytes: number; totalBytes: number }) => void
+	): globalThis.ReadableStream<Uint8Array> {
+		let transferredBytes = 0;
+
+		return new globalThis.ReadableStream({
+			async start(controller) {
+				const reader = body instanceof globalThis.ReadableStream ? body.getReader() : new globalThis.Response(body).body!.getReader();
+
+				async function read() {
+					const { done, value } = await reader.read();
+					if (done) {
+						controller.close();
+						return;
+					}
+
+					transferredBytes += value.byteLength;
+					const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+					onUploadProgress({ percent, transferredBytes, totalBytes });
+
+					controller.enqueue(value);
+					await read();
+				}
+
+				await read();
+			},
+		});
+	}
 }

source/core/constants.ts

@@ -67,6 +67,7 @@ export const kyOptionKeys: KyOptionsRegistry = {
 	hooks: true,
 	throwHttpErrors: true,
 	onDownloadProgress: true,
+	onUploadProgress: true,
 	fetch: true,
 };
 

source/types/options.ts

@@ -12,6 +12,16 @@ export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
 
 export type Input = string | URL | Request;
 
+export type UploadProgress = {
+	percent: number;
+	transferredBytes: number;
+
+	/**
+	Note: If it's not possible to retrieve the body size, it will be `0`.
+	*/
+	totalBytes: number;
+};
+
 export type DownloadProgress = {
 	percent: number;
 	transferredBytes: number;
@@ -188,6 +198,25 @@ export type KyOptions = {
 	*/
 	onDownloadProgress?: (progress: DownloadProgress, chunk: Uint8Array) => void;
 
+	/**
+	Upload progress event handler.
+
+	@param progress - Object containing upload progress information.
+
+	@example
+	```
+	import ky from 'ky';
+
+	const response = await ky.post('https://example.com/upload', {
+		body: new FormData(),
+		onUploadProgress: (progress) => {
+			console.log(`${progress.percent * 100}% - ${progress.transferredBytes} of ${progress.totalBytes} bytes`);
+		}
+	});
+	```
+	*/
+	onUploadProgress?: (progress: UploadProgress) => void;
+
 	/**
 	User-defined `fetch` function.
 	Has to be fully compatible with the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) standard.
@@ -287,6 +316,7 @@ export interface NormalizedOptions extends RequestInit { // eslint-disable-line
 	retry: RetryOptions;
 	prefixUrl: string;
 	onDownloadProgress: Options['onDownloadProgress'];
+	onUploadProgress: Options['onUploadProgress'];
 }
 
 export type {RetryOptions} from './retry.js';