got 14.6.5 → 15.0.0

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,31 +16,18 @@ 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 isCompressed = compressedEncodings.has(contentEncoding);
                 const { options } = request;
                 if (isCompressed && !options.decompress) {
                     response.body = response.rawBody;
@@ -52,14 +39,14 @@ export default function asPromise(firstRequest) {
                     catch (error) {
                         // Fall back to `utf8`
                         try {
-                            response.body = response.rawBody.toString();
+                            response.body = decodeUint8Array(response.rawBody);
                         }
                         catch (error) {
-                            request._beforeError(new ParseError(error, response));
+                            request._beforeError(new ParseError(normalizeError(error), response));
                             return;
                         }
                         if (isResponseOk(response)) {
-                            request._beforeError(error);
+                            request._beforeError(normalizeError(error));
                             return;
                         }
                     }
@@ -67,14 +54,41 @@ export default function asPromise(firstRequest) {
                 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
+                        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) => {
+                        response = await requestOptions.trackStateMutations(async (changedState) => hook(responseSnapshot, async (updatedOptions) => {
                             const preserveHooks = updatedOptions.preserveHooks ?? false;
-                            options.merge(updatedOptions);
-                            options.prefixUrl = '';
+                            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) {
-                                options.url = 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).
@@ -83,14 +97,14 @@ export default function asPromise(firstRequest) {
                                 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');
                         }
                     }
                 }
                 catch (error) {
-                    request._beforeError(error);
+                    request._beforeError(normalizeError(error));
                     return;
                 }
                 globalResponse = response;
@@ -104,9 +118,6 @@ export default function asPromise(firstRequest) {
             });
             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 +156,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 +172,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(/^\uFEFF/u, '') : 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;
@@ -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 {};