got 14.6.6 → 15.0.1

package/dist/source/as-promise/index.d.ts

@@ -1,3 +1,3 @@
 import Request from '../core/index.js';
-import { type CancelableRequest } from './types.js';
-export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T>;
+import { type RequestPromise } from './types.js';
+export default function asPromise<T>(firstRequest?: Request): RequestPromise<T>;

package/dist/source/as-promise/index.js

@@ -1,11 +1,11 @@
 import { EventEmitter } from 'node:events';
 import is from '@sindresorhus/is';
-import PCancelable from 'p-cancelable';
 import { HTTPError, RetryError, } from '../core/errors.js';
-import Request from '../core/index.js';
-import { parseBody, isResponseOk, ParseError, } from '../core/response.js';
+import Request, { normalizeError } from '../core/index.js';
+import { decodeUint8Array, isUtf8Encoding, parseBody, isResponseOk, ParseError, } from '../core/response.js';
 import proxyEvents from '../core/utils/proxy-events.js';
-import { CancelError } from './types.js';
+import { applyUrlOverride, isSameOrigin, snapshotCrossOriginState, } from '../core/options.js';
+const compressedEncodings = new Set(['gzip', 'deflate', 'br', 'zstd']);
 const proxiedRequestEvents = [
     'request',
     'response',
@@ -16,97 +16,110 @@ const proxiedRequestEvents = [
 export default function asPromise(firstRequest) {
     let globalRequest;
     let globalResponse;
-    let normalizedOptions;
     const emitter = new EventEmitter();
     let promiseSettled = false;
-    const promise = new PCancelable((resolve, reject, onCancel) => {
-        onCancel(() => {
-            globalRequest.destroy();
-        });
-        onCancel.shouldReject = false;
-        onCancel(() => {
-            promiseSettled = true;
-            reject(new CancelError(globalRequest));
-        });
-        const makeRequest = (retryCount) => {
-            // Errors when a new request is made after the promise settles.
-            // Used to detect a race condition.
-            // See https://github.com/sindresorhus/got/issues/1489
-            onCancel(() => { });
-            const request = firstRequest ?? new Request(undefined, undefined, normalizedOptions);
+    const promise = new Promise((resolve, reject) => {
+        const makeRequest = (retryCount, defaultOptions) => {
+            const request = firstRequest ?? new Request(undefined, undefined, defaultOptions);
             request.retryCount = retryCount;
             request._noPipe = true;
             globalRequest = request;
-            request.once('response', async (response) => {
-                // Parse body
-                const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
-                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br' || contentEncoding === 'zstd';
-                const { options } = request;
-                if (isCompressed && !options.decompress) {
-                    response.body = response.rawBody;
-                }
-                else {
-                    try {
-                        response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
+            request.once('response', (response) => {
+                void (async () => {
+                    // Parse body
+                    const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
+                    const isCompressed = compressedEncodings.has(contentEncoding);
+                    const { options } = request;
+                    if (isCompressed && !options.decompress) {
+                        response.body = response.rawBody;
                     }
-                    catch (error) {
-                        // Fall back to `utf8`
+                    else {
                         try {
-                            response.body = response.rawBody.toString();
+                            response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
                         }
                         catch (error) {
-                            request._beforeError(new ParseError(error, response));
-                            return;
-                        }
-                        if (isResponseOk(response)) {
-                            request._beforeError(error);
-                            return;
+                            // Fall back to `utf8`
+                            try {
+                                response.body = decodeUint8Array(response.rawBody);
+                            }
+                            catch (error) {
+                                request._beforeError(new ParseError(normalizeError(error), response));
+                                return;
+                            }
+                            if (isResponseOk(response)) {
+                                request._beforeError(normalizeError(error));
+                                return;
+                            }
                         }
                     }
-                }
-                try {
-                    const hooks = options.hooks.afterResponse;
-                    for (const [index, hook] of hooks.entries()) {
-                        // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
-                        // eslint-disable-next-line no-await-in-loop
-                        response = await hook(response, async (updatedOptions) => {
-                            const preserveHooks = updatedOptions.preserveHooks ?? false;
-                            options.merge(updatedOptions);
-                            options.prefixUrl = '';
-                            if (updatedOptions.url) {
-                                options.url = updatedOptions.url;
-                            }
-                            // Remove any further hooks for that request, because we'll call them anyway.
-                            // The loop continues. We don't want duplicates (asPromise recursion).
-                            // Unless preserveHooks is true, in which case we keep the remaining hooks.
-                            if (!preserveHooks) {
-                                options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
+                    try {
+                        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 requestOptions.trackStateMutations(async (changedState) => hook(responseSnapshot, async (updatedOptions) => {
+                                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();
+                                }
+                                if (!reusesRequestOptions) {
+                                    options.merge(updatedOptions);
+                                }
+                                if (updatedOptions.url) {
+                                    const nextUrl = reusesRequestOptions
+                                        ? options.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.
+                                // The loop continues. We don't want duplicates (asPromise recursion).
+                                // Unless preserveHooks is true, in which case we keep the remaining hooks.
+                                if (!preserveHooks) {
+                                    options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
+                                }
+                                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');
                             }
-                            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');
                         }
                     }
-                }
-                catch (error) {
-                    request._beforeError(error);
-                    return;
-                }
-                globalResponse = response;
-                if (!isResponseOk(response)) {
-                    request._beforeError(new HTTPError(response));
-                    return;
-                }
-                request.destroy();
-                promiseSettled = true;
-                resolve(request.options.resolveBodyOnly ? response.body : response);
+                    catch (error) {
+                        request._beforeError(normalizeError(error));
+                        return;
+                    }
+                    globalResponse = response;
+                    if (!isResponseOk(response)) {
+                        request._beforeError(new HTTPError(response));
+                        return;
+                    }
+                    request.destroy();
+                    promiseSettled = true;
+                    resolve(request.options.resolveBodyOnly ? response.body : response);
+                })();
             });
             let handledFinalError = false;
             const onError = (error) => {
-                if (promise.isCanceled) {
-                    return;
-                }
                 // Route errors emitted directly on the stream (e.g., EPIPE from Node.js)
                 // through retry logic first, then handle them here after retries are exhausted.
                 // See https://github.com/sindresorhus/got/issues/1995
@@ -145,15 +158,14 @@ export default function asPromise(firstRequest) {
                     return;
                 }
                 const newBody = request.options.body;
-                if (previousBody === newBody && is.nodeStream(newBody)) {
+                if (previousBody === newBody && (is.nodeStream(newBody) || newBody instanceof ReadableStream)) {
                     error.message = 'Cannot retry with consumed body stream';
                     onError(error);
                     return;
                 }
                 // This is needed! We need to reuse `request.options` because they can get modified!
                 // For example, by calling `promise.json()`.
-                normalizedOptions = request.options;
-                makeRequest(newRetryCount);
+                makeRequest(newRetryCount, request.options);
             });
             proxyEvents(request, emitter, proxiedRequestEvents);
             if (is.undefined(firstRequest)) {
@@ -162,19 +174,27 @@ export default function asPromise(firstRequest) {
         };
         makeRequest(0);
     });
-    promise.on = (event, function_) => {
+    promise.on = function (event, function_) {
         emitter.on(event, function_);
-        return promise;
+        return this;
+    };
+    promise.once = function (event, function_) {
+        emitter.once(event, function_);
+        return this;
     };
-    promise.off = (event, function_) => {
+    promise.off = function (event, function_) {
         emitter.off(event, function_);
-        return promise;
+        return this;
     };
     const shortcut = (promiseToAwait, responseType) => {
         const newPromise = (async () => {
             // Wait until downloading has ended
             await promiseToAwait;
             const { options } = globalResponse.request;
+            if (responseType === 'text') {
+                const text = decodeUint8Array(globalResponse.rawBody, options.encoding);
+                return (isUtf8Encoding(options.encoding) ? text.replace(/^\u{FEFF}/v, '') : text);
+            }
             return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
         })();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises

package/dist/source/as-promise/types.d.ts

@@ -1,37 +1,24 @@
-import type { Buffer } from 'node:buffer';
-import type PCancelable from 'p-cancelable';
-import { RequestError } from '../core/errors.js';
-import type Request from '../core/index.js';
 import { type RequestEvents } from '../core/index.js';
 import type { Response } from '../core/response.js';
-/**
-An error to be thrown when the request is aborted with `.cancel()`.
-*/
-export declare class CancelError extends RequestError {
-    readonly response: Response;
-    constructor(request: Request);
-    /**
-    Whether the promise is canceled.
-    */
-    get isCanceled(): boolean;
-}
-export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
+interface RequestPromiseShape<T extends Response | Response['body'] = Response['body']> extends RequestEvents<RequestPromise<T>> {
     /**
     A shortcut method that gives a Promise returning a JSON object.
 
-    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'json'`.
+    It is semantically the same as setting `options.resolveBodyOnly` to `true` and `options.responseType` to `'json'`.
     */
-    json: <ReturnType>() => CancelableRequest<ReturnType>;
+    json: <ReturnType>() => RequestPromise<ReturnType>;
     /**
-    A shortcut method that gives a Promise returning a [Buffer](https://nodejs.org/api/buffer.html).
+    A shortcut method that gives a Promise returning a [Uint8Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
 
-    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
+    It is semantically the same as setting `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
     */
-    buffer: () => CancelableRequest<Buffer>;
+    buffer: () => RequestPromise<Uint8Array<ArrayBuffer>>;
     /**
     A shortcut method that gives a Promise returning a string.
 
-    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'text'`.
+    It is semantically the same as setting `options.resolveBodyOnly` to `true` and `options.responseType` to `'text'`.
     */
-    text: () => CancelableRequest<string>;
+    text: () => RequestPromise<string>;
 }
+export type RequestPromise<T extends Response | Response['body'] = Response['body']> = Promise<T> & RequestPromiseShape<T>;
+export {};

package/dist/source/as-promise/types.js

@@ -1,17 +1 @@
-import { RequestError } from '../core/errors.js';
-/**
-An error to be thrown when the request is aborted with `.cancel()`.
-*/
-export class CancelError extends RequestError {
-    constructor(request) {
-        super('Promise was canceled', {}, request);
-        this.name = 'CancelError';
-        this.code = 'ERR_CANCELED';
-    }
-    /**
-    Whether the promise is canceled.
-    */
-    get isCanceled() {
-        return true;
-    }
-}
+export {};

package/dist/source/core/calculate-retry-delay.js

@@ -14,10 +14,7 @@ const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter, co
     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) {
             return 0;

package/dist/source/core/diagnostics-channel.js

@@ -12,38 +12,29 @@ const channels = {
 export function generateRequestId() {
     return randomUUID();
 }
-export function publishRequestCreate(message) {
-    if (channels.requestCreate.hasSubscribers) {
-        channels.requestCreate.publish(message);
+const publishToChannel = (channel, message) => {
+    if (channel.hasSubscribers) {
+        channel.publish(message);
     }
+};
+export function publishRequestCreate(message) {
+    publishToChannel(channels.requestCreate, message);
 }
 export function publishRequestStart(message) {
-    if (channels.requestStart.hasSubscribers) {
-        channels.requestStart.publish(message);
-    }
+    publishToChannel(channels.requestStart, message);
 }
 export function publishResponseStart(message) {
-    if (channels.responseStart.hasSubscribers) {
-        channels.responseStart.publish(message);
-    }
+    publishToChannel(channels.responseStart, message);
 }
 export function publishResponseEnd(message) {
-    if (channels.responseEnd.hasSubscribers) {
-        channels.responseEnd.publish(message);
-    }
+    publishToChannel(channels.responseEnd, message);
 }
 export function publishRetry(message) {
-    if (channels.retry.hasSubscribers) {
-        channels.retry.publish(message);
-    }
+    publishToChannel(channels.retry, message);
 }
 export function publishError(message) {
-    if (channels.error.hasSubscribers) {
-        channels.error.publish(message);
-    }
+    publishToChannel(channels.error, message);
 }
 export function publishRedirect(message) {
-    if (channels.redirect.hasSubscribers) {
-        channels.redirect.publish(message);
-    }
+    publishToChannel(channels.redirect, message);
 }

package/dist/source/core/errors.d.ts

@@ -37,7 +37,7 @@ export declare class MaxRedirectsError extends RequestError {
 An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
 Includes a `response` property.
 */
-export declare class HTTPError<T = any> extends RequestError<T> {
+export declare class HTTPError<T = unknown> extends RequestError<T> {
     name: string;
     code: string;
     readonly response: Response<T>;
@@ -78,6 +78,7 @@ An error to be thrown when reading from response stream fails.
 */
 export declare class ReadError extends RequestError {
     name: string;
+    code: string;
     readonly request: Request;
     readonly response: Response;
     readonly timings: Timings;

package/dist/source/core/errors.js

@@ -1,4 +1,5 @@
 import is from '@sindresorhus/is';
+import stripUrlAuth from './utils/strip-url-auth.js';
 // A hacky check to prevent circular references.
 function isRequest(x) {
     return is.object(x) && '_onResponse' in x;
@@ -40,13 +41,13 @@ export class RequestError extends Error {
         // Recover the original stacktrace
         if (is.string(error.stack) && is.string(this.stack)) {
             const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
-            const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
-            const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse();
+            const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').toReversed();
+            const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').toReversed();
             // Remove duplicated traces
             while (errorStackTrace.length > 0 && errorStackTrace[0] === thisStackTrace[0]) {
                 thisStackTrace.shift();
             }
-            this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
+            this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.toReversed().join('\n')}${errorStackTrace.toReversed().join('\n')}`;
         }
     }
 }
@@ -65,13 +66,12 @@ export class MaxRedirectsError extends RequestError {
 An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
 Includes a `response` property.
 */
-// TODO: Change `HTTPError<T = any>` to `HTTPError<T = unknown>` in the next major version to enforce type usage.
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export class HTTPError extends RequestError {
     name = 'HTTPError';
     code = 'ERR_NON_2XX_3XX_RESPONSE';
     constructor(response) {
-        super(`Request failed with status code ${response.statusCode} (${response.statusMessage}): ${response.request.options.method} ${response.request.options.url.toString()}`, {}, response.request);
+        super(`Request failed with status code ${response.statusCode} (${response.statusMessage}): ${response.request.options.method} ${stripUrlAuth(response.request.options.url)}`, {}, response.request);
     }
 }
 /**
@@ -82,9 +82,7 @@ export class CacheError extends RequestError {
     name = 'CacheError';
     constructor(error, request) {
         super(error.message, error, request);
-        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
-            this.code = 'ERR_CACHE_ACCESS';
-        }
+        this.code = 'ERR_CACHE_ACCESS';
     }
 }
 /**
@@ -94,9 +92,7 @@ export class UploadError extends RequestError {
     name = 'UploadError';
     constructor(error, request) {
         super(error.message, error, request);
-        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
-            this.code = 'ERR_UPLOAD';
-        }
+        this.code = 'ERR_UPLOAD';
     }
 }
 /**
@@ -118,10 +114,11 @@ An error to be thrown when reading from response stream fails.
 */
 export class ReadError extends RequestError {
     name = 'ReadError';
+    code = 'ERR_READING_RESPONSE_STREAM';
     constructor(error, 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;
         }
     }
 }

package/dist/source/core/index.d.ts

@@ -77,6 +77,8 @@ export type RequestEvents<T> = {
     once: GotEventFunction<T>;
     off: GotEventFunction<T>;
 };
+export { crossOriginStripHeaders } from './options.js';
+export declare const normalizeError: (error: unknown) => Error;
 type UrlType = ConstructorParameters<typeof Options>[0];
 type OptionsType = ConstructorParameters<typeof Options>[1];
 type DefaultsType = ConstructorParameters<typeof Options>[2];
@@ -90,24 +92,24 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     retryCount: number;
     _stopReading: boolean;
     private _requestOptions;
-    private _stopRetry;
+    private _stopRetry?;
     private _downloadedSize;
     private _uploadedSize;
     private readonly _pipedServerResponses;
     private _request?;
     private _responseSize?;
     private _bodySize?;
-    private _unproxyEvents;
-    private _isFromCache?;
+    private _unproxyEvents?;
     private _triggerRead;
     private readonly _jobs;
-    private _cancelTimeouts;
-    private readonly _removeListeners;
-    private _nativeResponse?;
+    private _cancelTimeouts?;
+    private readonly _abortListenerDisposer?;
     private _flushed;
     private _aborted;
     private _expectedContentLength?;
     private _compressedBytesCount?;
+    private _skipRequestEndInFinal;
+    private _incrementalDecode?;
     private readonly _requestId;
     private _requestInitialized;
     constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType);
@@ -121,14 +123,25 @@ export default class Request extends Duplex implements RequestEvents<Request> {
         end?: boolean;
     }): T;
     unpipe<T extends NodeJS.WritableStream>(destination: T): this;
+    private _shouldIncrementallyDecodeBody;
     private _checkContentLengthMismatch;
     private _finalizeBody;
     private _onResponseBase;
     private _setRawBody;
     private _onResponse;
     private _onRequest;
+    private _isRequestStale;
     private _asyncWrite;
     private _sendBody;
+    private _writeBodyInChunks;
+    private _finalizeStaleChunkedWrite;
+    private _emitUploadComplete;
+    private _endWritableRequest;
+    private _stripCrossOriginState;
+    private _stripUnchangedCrossOriginState;
+    private _dropBody;
+    private readonly _onBodyError;
+    private _writeChunksToRequest;
     private _prepareCache;
     private _createCacheableRequest;
     private _makeRequest;
@@ -189,4 +202,3 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     */
     get isReadonly(): boolean;
 }
-export {};