Various improvements

Author: sindresorhus

package.json

@@ -61,7 +61,8 @@
 		"keyv": "^5.6.0",
 		"lowercase-keys": "^4.0.1",
 		"responselike": "^4.0.2",
-		"type-fest": "^5.4.4"
+		"type-fest": "^5.4.4",
+		"uint8array-extras": "^1.5.0"
 	},
 	"devDependencies": {
 		"@hapi/bourne": "^3.0.0",

source/as-promise/index.ts

@@ -1,21 +1,29 @@
-import {Buffer} from 'node:buffer';
 import {EventEmitter} from 'node:events';
 import is from '@sindresorhus/is';
 import {
 	HTTPError,
 	RetryError,
 	type RequestError,
 } from '../core/errors.js';
-import Request from '../core/index.js';
+import Request, {normalizeError} from '../core/index.js';
 import {
+	decodeUint8Array,
+	isUtf8Encoding,
 	parseBody,
 	isResponseOk,
 	type Response, ParseError,
 } from '../core/response.js';
 import proxyEvents from '../core/utils/proxy-events.js';
+import {
+	applyUrlOverride,
+	isSameOrigin,
+	snapshotCrossOriginState,
+} from '../core/options.js';
 import type Options from '../core/options.js';
 import {type RequestPromise} from './types.js';
 
+const compressedEncodings = new Set(['gzip', 'deflate', 'br', 'zstd']);
+
 const proxiedRequestEvents = [
 	'request',
 	'response',
@@ -24,34 +32,6 @@ const proxiedRequestEvents = [
 	'downloadProgress',
 ];
 
-const normalizeError = (error: unknown): Error => {
-	if (error instanceof Error) {
-		return error;
-	}
-
-	if (is.object(error)) {
-		const errorLike = error as Partial<Error & {code?: string; input?: string}>;
-		const message = typeof errorLike.message === 'string' ? errorLike.message : 'Non-error object thrown';
-		const normalizedError = new Error(message, {cause: error}) as Error & {code?: string; input?: string};
-
-		if (typeof errorLike.stack === 'string') {
-			normalizedError.stack = errorLike.stack;
-		}
-
-		if (typeof errorLike.code === 'string') {
-			normalizedError.code = errorLike.code;
-		}
-
-		if (typeof errorLike.input === 'string') {
-			normalizedError.input = errorLike.input;
-		}
-
-		return normalizedError;
-	}
-
-	return new Error(String(error));
-};
-
 export default function asPromise<T>(firstRequest?: Request): RequestPromise<T> {
 	let globalRequest: Request;
 	let globalResponse: Response;
@@ -69,7 +49,7 @@ export default function asPromise<T>(firstRequest?: Request): RequestPromise<T>
 			request.once('response', async (response: Response) => {
 				// Parse body
 				const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
-				const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br' || contentEncoding === 'zstd';
+				const isCompressed = compressedEncodings.has(contentEncoding);
 
 				const {options} = request;
 
@@ -81,7 +61,7 @@ export default function asPromise<T>(firstRequest?: Request): RequestPromise<T>
 					} catch (error: unknown) {
 						// Fall back to `utf8`
 						try {
-							response.body = Buffer.from(response.rawBody).toString();
+							response.body = decodeUint8Array(response.rawBody);
 						} catch (error) {
 							request._beforeError(new ParseError(normalizeError(error), response));
 							return;
@@ -98,16 +78,46 @@ export default function asPromise<T>(firstRequest?: Request): RequestPromise<T>
 					const hooks = options.hooks.afterResponse;
 
 					for (const [index, hook] of hooks.entries()) {
+						const previousUrl = options.url ? new URL(options.url) : undefined;
+						const previousState = previousUrl ? snapshotCrossOriginState(options) : undefined;
+						const requestOptions = response.request.options;
+						const responseSnapshot = response;
+
 						// @ts-expect-error TS doesn't notice that RequestPromise is a Promise
 						// eslint-disable-next-line no-await-in-loop
-						response = await hook(response, async (updatedOptions): RequestPromise<Response> => {
+						response = await requestOptions.trackStateMutations(async changedState => hook(responseSnapshot, async (updatedOptions): RequestPromise<Response> => {
 							const preserveHooks = updatedOptions.preserveHooks ?? false;
+							const reusesRequestOptions = updatedOptions === requestOptions;
+							const hasExplicitBody = reusesRequestOptions
+								? changedState.has('body') || changedState.has('json') || changedState.has('form')
+								: (Object.hasOwn(updatedOptions, 'body') && updatedOptions.body !== undefined)
+									|| (Object.hasOwn(updatedOptions, 'json') && updatedOptions.json !== undefined)
+									|| (Object.hasOwn(updatedOptions, 'form') && updatedOptions.form !== undefined);
+
+							if (hasExplicitBody && !reusesRequestOptions) {
+								options.clearBody();
+							}
 
-							options.merge(updatedOptions);
-							options.prefixUrl = '';
+							if (!reusesRequestOptions) {
+								options.merge(updatedOptions);
+							}
 
 							if (updatedOptions.url) {
-								options.url = updatedOptions.url;
+								const nextUrl = reusesRequestOptions
+									? options.url as URL
+									: applyUrlOverride(options, updatedOptions.url, updatedOptions);
+
+								if (previousUrl) {
+									if (reusesRequestOptions && !isSameOrigin(previousUrl, nextUrl)) {
+										options.stripUnchangedCrossOriginState(previousState!, changedState, {clearBody: !hasExplicitBody});
+									} else {
+										options.stripSensitiveHeaders(previousUrl, nextUrl, updatedOptions);
+
+										if (!isSameOrigin(previousUrl, nextUrl) && !hasExplicitBody) {
+											options.clearBody();
+										}
+									}
+								}
 							}
 
 							// Remove any further hooks for that request, because we'll call them anyway.
@@ -118,7 +128,7 @@ export default function asPromise<T>(firstRequest?: Request): RequestPromise<T>
 							}
 
 							throw new RetryError(request);
-						});
+						}));
 
 						if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
 							throw new TypeError('The `afterResponse` hook returned an invalid value');
@@ -238,6 +248,11 @@ export default function asPromise<T>(firstRequest?: Request): RequestPromise<T>
 
 			const {options} = globalResponse.request;
 
+			if (responseType === 'text') {
+				const text = decodeUint8Array(globalResponse.rawBody, options.encoding);
+				return (isUtf8Encoding(options.encoding) ? text.replace(/^\uFEFF/u, '') : text) as T;
+			}
+
 			return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
 		})();
 

source/as-promise/types.ts

@@ -15,7 +15,7 @@ interface RequestPromiseShape<T extends Response | Response['body'] = Response['
 
 	It is semantically the same as setting `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
 	*/
-	buffer: () => RequestPromise<Uint8Array>;
+	buffer: () => RequestPromise<Uint8Array<ArrayBuffer>>;
 
 	/**
 	A shortcut method that gives a Promise returning a string.

source/core/calculate-retry-delay.ts

@@ -27,11 +27,7 @@ const calculateRetryDelay: Returns<RetryFunction, number> = ({
 	if (error.response) {
 		if (retryAfter) {
 			// In this case `computedValue` is `options.request.timeout`
-			if (retryAfter > computedValue) {
-				return 0;
-			}
-
-			return retryAfter;
+			return retryAfter > computedValue ? 0 : retryAfter;
 		}
 
 		if (error.response.statusCode === 413) {

source/core/diagnostics-channel.ts

@@ -104,44 +104,36 @@ export function generateRequestId(): RequestId {
 	return randomUUID();
 }
 
-export function publishRequestCreate(message: DiagnosticRequestCreate): void {
-	if (channels.requestCreate.hasSubscribers) {
-		channels.requestCreate.publish(message);
+const publishToChannel = (channel: diagnosticsChannel.Channel, message: unknown): void => {
+	if (channel.hasSubscribers) {
+		channel.publish(message);
 	}
+};
+
+export function publishRequestCreate(message: DiagnosticRequestCreate): void {
+	publishToChannel(channels.requestCreate, message);
 }
 
 export function publishRequestStart(message: DiagnosticRequestStart): void {
-	if (channels.requestStart.hasSubscribers) {
-		channels.requestStart.publish(message);
-	}
+	publishToChannel(channels.requestStart, message);
 }
 
 export function publishResponseStart(message: DiagnosticResponseStart): void {
-	if (channels.responseStart.hasSubscribers) {
-		channels.responseStart.publish(message);
-	}
+	publishToChannel(channels.responseStart, message);
 }
 
 export function publishResponseEnd(message: DiagnosticResponseEnd): void {
-	if (channels.responseEnd.hasSubscribers) {
-		channels.responseEnd.publish(message);
-	}
+	publishToChannel(channels.responseEnd, message);
 }
 
 export function publishRetry(message: DiagnosticRequestRetry): void {
-	if (channels.retry.hasSubscribers) {
-		channels.retry.publish(message);
-	}
+	publishToChannel(channels.retry, message);
 }
 
 export function publishError(message: DiagnosticRequestError): void {
-	if (channels.error.hasSubscribers) {
-		channels.error.publish(message);
-	}
+	publishToChannel(channels.error, message);
 }
 
 export function publishRedirect(message: DiagnosticResponseRedirect): void {
-	if (channels.redirect.hasSubscribers) {
-		channels.redirect.publish(message);
-	}
+	publishToChannel(channels.redirect, message);
 }

source/core/errors.ts

@@ -114,9 +114,7 @@ export class CacheError extends RequestError {
 
 	constructor(error: Error, request: Request) {
 		super(error.message, error, request);
-		if (this.code === 'ERR_GOT_REQUEST_ERROR') {
-			this.code = 'ERR_CACHE_ACCESS';
-		}
+		this.code = 'ERR_CACHE_ACCESS';
 	}
 }
 
@@ -129,9 +127,7 @@ export class UploadError extends RequestError {
 
 	constructor(error: Error, request: Request) {
 		super(error.message, error, request);
-		if (this.code === 'ERR_GOT_REQUEST_ERROR') {
-			this.code = 'ERR_UPLOAD';
-		}
+		this.code = 'ERR_UPLOAD';
 	}
 }
 
@@ -157,14 +153,16 @@ An error to be thrown when reading from response stream fails.
 */
 export class ReadError extends RequestError {
 	override name = 'ReadError';
+	override code = 'ERR_READING_RESPONSE_STREAM';
 	declare readonly request: Request;
 	declare readonly response: Response;
 	declare readonly timings: Timings;
 
 	constructor(error: Error, request: Request) {
 		super(error.message, error, request);
-		if (this.code === 'ERR_GOT_REQUEST_ERROR') {
-			this.code = 'ERR_READING_RESPONSE_STREAM';
+
+		if (error.code === 'ECONNRESET' || error.code === 'ERR_HTTP_CONTENT_LENGTH_MISMATCH') {
+			this.code = error.code;
 		}
 	}
 }