got 14.6.6 → 15.0.0

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

@@ -1,8 +1,9 @@
-import type { Buffer } from 'node:buffer';
 import type { IncomingMessageWithTimings, Timings } from './utils/timer.js';
 import { RequestError } from './errors.js';
 import type { ParseJsonFunction, ResponseType } from './options.js';
 import type Request from './index.js';
+export declare const isUtf8Encoding: (encoding?: BufferEncoding) => boolean;
+export declare const decodeUint8Array: (data: Uint8Array, encoding?: BufferEncoding) => string;
 export type PlainResponse = {
     /**
     The original request URL.
@@ -73,7 +74,7 @@ export type PlainResponse = {
     /**
     The raw result of the request.
     */
-    rawBody?: Buffer;
+    rawBody?: Uint8Array<ArrayBuffer>;
     /**
     The result of the request.
     */
@@ -93,7 +94,7 @@ export type Response<T = unknown> = {
     /**
     The raw result of the request.
     */
-    rawBody: Buffer;
+    rawBody: Uint8Array<ArrayBuffer>;
 } & PlainResponse;
 export declare const isResponseOk: (response: PlainResponse) => boolean;
 /**
@@ -106,4 +107,5 @@ export declare class ParseError extends RequestError {
     readonly response: Response;
     constructor(error: Error, response: Response);
 }
+export declare const cacheDecodedBody: (response: PlainResponse, decodedBody: string) => void;
 export declare const parseBody: (response: Response, responseType: ResponseType, parseJson: ParseJsonFunction, encoding?: BufferEncoding) => unknown;

package/dist/source/core/response.js

@@ -1,4 +1,16 @@
+import { Buffer } from 'node:buffer';
 import { RequestError } from './errors.js';
+import stripUrlAuth from './utils/strip-url-auth.js';
+const decodedBodyCache = new WeakMap();
+// Intentionally uses TextDecoder so the UTF-8 path strips a leading BOM.
+const textDecoder = new TextDecoder();
+export const isUtf8Encoding = (encoding) => encoding === undefined || encoding.toLowerCase().replace('-', '') === 'utf8';
+export const decodeUint8Array = (data, encoding) => {
+    if (isUtf8Encoding(encoding)) {
+        return textDecoder.decode(data);
+    }
+    return Buffer.from(data).toString(encoding);
+};
 export const isResponseOk = (response) => {
     const { statusCode } = response;
     const { followRedirect } = response.request.options;
@@ -15,17 +27,28 @@ export class ParseError extends RequestError {
     code = 'ERR_BODY_PARSE_FAILURE';
     constructor(error, response) {
         const { options } = response.request;
-        super(`${error.message} in "${options.url.toString()}"`, error, response.request);
+        super(`${error.message} in "${stripUrlAuth(options.url)}"`, error, response.request);
     }
 }
+export const cacheDecodedBody = (response, decodedBody) => {
+    decodedBodyCache.set(response, decodedBody);
+};
 export const parseBody = (response, responseType, parseJson, encoding) => {
     const { rawBody } = response;
+    const cachedDecodedBody = decodedBodyCache.get(response);
     try {
         if (responseType === 'text') {
-            return rawBody.toString(encoding);
+            if (cachedDecodedBody !== undefined) {
+                return cachedDecodedBody;
+            }
+            return decodeUint8Array(rawBody, encoding);
         }
         if (responseType === 'json') {
-            return rawBody.length === 0 ? '' : parseJson(rawBody.toString(encoding));
+            if (rawBody.length === 0) {
+                return '';
+            }
+            const text = cachedDecodedBody ?? decodeUint8Array(rawBody, encoding);
+            return parseJson(text);
         }
         if (responseType === 'buffer') {
             return rawBody;

package/dist/source/core/timed-out.d.ts

@@ -17,9 +17,9 @@ export type Delays = {
 };
 export type ErrorCode = 'ETIMEDOUT' | 'ECONNRESET' | 'EADDRINUSE' | 'ECONNREFUSED' | 'EPIPE' | 'ENOTFOUND' | 'ENETUNREACH' | 'EAI_AGAIN';
 export declare class TimeoutError extends Error {
-    event: string;
     name: string;
     code: ErrorCode;
+    event: string;
     constructor(threshold: number, event: string);
 }
 export default function timedOut(request: ClientRequest, delays: Delays, options: TimedOutOptions): () => void;

package/dist/source/core/timed-out.js

@@ -3,9 +3,9 @@ import unhandler from './utils/unhandle.js';
 const reentry = Symbol('reentry');
 const noop = () => { };
 export class TimeoutError extends Error {
-    event;
     name = 'TimeoutError';
     code = 'ETIMEDOUT';
+    event;
     constructor(threshold, event) {
         super(`Timeout awaiting '${event}' for ${threshold}ms`);
         this.event = event;
@@ -18,12 +18,12 @@ export default function timedOut(request, delays, options) {
     request[reentry] = true;
     const cancelers = [];
     const { once, unhandleAll } = unhandler();
-    const handled = new Map();
+    const handled = new Set();
     const addTimeout = (delay, callback, event) => {
         const timeout = setTimeout(callback, delay, delay, event);
         timeout.unref?.();
         const cancel = () => {
-            handled.set(event, true);
+            handled.add(event);
             clearTimeout(timeout);
         };
         cancelers.push(cancel);

package/dist/source/core/utils/defer-to-connect.js

@@ -2,22 +2,10 @@ function isTlsSocket(socket) {
     return 'encrypted' in socket;
 }
 const deferToConnect = (socket, fn) => {
-    let listeners;
-    if (typeof fn === 'function') {
-        const connect = fn;
-        listeners = { connect };
-    }
-    else {
-        listeners = fn;
-    }
-    const hasConnectListener = typeof listeners.connect === 'function';
-    const hasSecureConnectListener = typeof listeners.secureConnect === 'function';
-    const hasCloseListener = typeof listeners.close === 'function';
+    const listeners = typeof fn === 'function' ? { connect: fn } : fn;
     const onConnect = () => {
-        if (hasConnectListener) {
-            listeners.connect();
-        }
-        if (isTlsSocket(socket) && hasSecureConnectListener) {
+        listeners.connect?.();
+        if (isTlsSocket(socket) && listeners.secureConnect) {
             if (socket.authorized) {
                 listeners.secureConnect();
             }
@@ -26,7 +14,7 @@ const deferToConnect = (socket, fn) => {
                 socket.once('secureConnect', listeners.secureConnect);
             }
         }
-        if (hasCloseListener) {
+        if (listeners.close) {
             socket.once('close', listeners.close);
         }
     };
@@ -36,7 +24,7 @@ const deferToConnect = (socket, fn) => {
     else if (socket.connecting) {
         socket.once('connect', onConnect);
     }
-    else if (socket.destroyed && hasCloseListener) {
+    else if (socket.destroyed && listeners.close) {
         const hadError = '_hadError' in socket ? Boolean(socket._hadError) : false;
         listeners.close(hadError);
     }

package/dist/source/core/utils/get-body-size.d.ts

@@ -1,2 +1,2 @@
 import type { ClientRequestArgs } from 'node:http';
-export default function getBodySize(body: unknown, headers: ClientRequestArgs['headers']): Promise<number | undefined>;
+export default function getBodySize(body: unknown, headers: ClientRequestArgs['headers']): number | undefined;

package/dist/source/core/utils/get-body-size.js

@@ -1,7 +1,6 @@
-import { promisify } from 'node:util';
 import is from '@sindresorhus/is';
-import isFormData from './is-form-data.js';
-export default async function getBodySize(body, headers) {
+import { stringToUint8Array } from 'uint8array-extras';
+export default function getBodySize(body, headers) {
     if (headers && 'content-length' in headers) {
         return Number(headers['content-length']);
     }
@@ -9,7 +8,7 @@ export default async function getBodySize(body, headers) {
         return 0;
     }
     if (is.string(body)) {
-        return new TextEncoder().encode(body).byteLength;
+        return stringToUint8Array(body).byteLength;
     }
     if (is.buffer(body)) {
         return body.length;
@@ -17,21 +16,5 @@ export default async function getBodySize(body, headers) {
     if (is.typedArray(body)) {
         return body.byteLength;
     }
-    if (isFormData(body)) {
-        try {
-            return await promisify(body.getLength.bind(body))();
-        }
-        catch (error) {
-            const typedError = error;
-            throw new Error('Cannot determine content-length for form-data with stream(s) of unknown length. '
-                + 'This is a limitation of the `form-data` package. '
-                + 'To fix this, either:\n'
-                + '1. Use the `knownLength` option when appending streams:\n'
-                + '   form.append(\'file\', stream, {knownLength: 12345});\n'
-                + '2. Switch to spec-compliant FormData (formdata-node package)\n'
-                + 'See: https://github.com/form-data/form-data#alternative-submission-methods\n'
-                + `Original error: ${typedError.message}`);
-        }
-    }
     return undefined;
 }

package/dist/source/core/utils/proxy-events.d.ts

@@ -1,2 +1,2 @@
 import type { EventEmitter } from 'node:events';
-export default function proxyEvents(from: EventEmitter, to: EventEmitter, events: Readonly<string[]>): () => void;
+export default function proxyEvents(from: EventEmitter, to: EventEmitter, events: readonly string[]): () => void;

package/dist/source/core/utils/proxy-events.js

@@ -1,14 +1,14 @@
 export default function proxyEvents(from, to, events) {
-    const eventFunctions = {};
+    const eventFunctions = new Map();
     for (const event of events) {
         const eventFunction = (...arguments_) => {
             to.emit(event, ...arguments_);
         };
-        eventFunctions[event] = eventFunction;
+        eventFunctions.set(event, eventFunction);
         from.on(event, eventFunction);
     }
     return () => {
-        for (const [event, eventFunction] of Object.entries(eventFunctions)) {
+        for (const [event, eventFunction] of eventFunctions) {
             from.off(event, eventFunction);
         }
     };

package/dist/source/core/utils/strip-url-auth.d.ts

@@ -0,0 +1 @@
+export default function stripUrlAuth(url: URL | string): string;

package/dist/source/core/utils/strip-url-auth.js

@@ -0,0 +1,9 @@
+/*
+Returns the URL as a string with `username` and `password` stripped.
+*/
+export default function stripUrlAuth(url) {
+    const sanitized = new URL(url);
+    sanitized.username = '';
+    sanitized.password = '';
+    return sanitized.toString();
+}

package/dist/source/core/utils/timer.js

@@ -100,13 +100,11 @@ const timer = (request) => {
                     timings.phases.dns = 0;
                 }
                 // Store connection phase timings on socket for potential reuse
-                if (!socket.__initial_connection_timings__) {
-                    socket.__initial_connection_timings__ = {
-                        dnsPhase: timings.phases.dns,
-                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript can't prove this is defined due to callback structure
-                        tcpPhase: timings.phases.tcp,
-                    };
-                }
+                socket.__initial_connection_timings__ ??= {
+                    dnsPhase: timings.phases.dns,
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript can't prove this is defined due to callback structure
+                    tcpPhase: timings.phases.tcp,
+                };
             },
             secureConnect() {
                 timings.secureConnect = Date.now();

package/dist/source/core/utils/unhandle.js

@@ -10,8 +10,7 @@ export default function unhandle() {
             handlers.push({ origin, event, fn: function_ });
         },
         unhandleAll() {
-            for (const handler of handlers) {
-                const { origin, event, fn } = handler;
+            for (const { origin, event, fn } of handlers) {
                 origin.removeListener(event, fn);
             }
             handlers.length = 0;

package/dist/source/create.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import is, { assert } from '@sindresorhus/is';
 import asPromise from './as-promise/index.js';
 import Request from './core/index.js';
-import Options from './core/options.js';
+import Options, { applyUrlOverride, isSameOrigin, snapshotCrossOriginState, } from './core/options.js';
 const isGotInstance = (value) => is.function(value);
 const aliases = [
     'get',
@@ -12,6 +12,22 @@ const aliases = [
     'head',
     'delete',
 ];
+const optionsObjectUrlErrorMessage = 'The `url` option is not supported in options objects. Pass it as the first argument instead.';
+const assertNoUrlInOptionsObject = (options) => {
+    if (Object.hasOwn(options, 'url')) {
+        throw new TypeError(optionsObjectUrlErrorMessage);
+    }
+};
+const cloneWithProperty = (value, property, propertyValue) => {
+    const clone = Object.create(Object.getPrototypeOf(value), Object.getOwnPropertyDescriptors(value));
+    Object.defineProperty(clone, property, {
+        value: propertyValue,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+    return clone;
+};
 const create = (defaults) => {
     defaults = {
         options: new Options(undefined, undefined, defaults.options),
@@ -23,19 +39,32 @@ const create = (defaults) => {
         configurable: false,
         writable: false,
     });
-    // Got interface
-    const got = ((url, options, defaultOptions = defaults.options) => {
-        const request = new Request(url, options, defaultOptions);
+    const makeRequest = (url, options, defaultOptions, isStream) => {
+        if (is.plainObject(url)) {
+            assertNoUrlInOptionsObject(url);
+        }
+        if (is.plainObject(options)) {
+            assertNoUrlInOptionsObject(options);
+        }
+        // `isStream` is skipped by `merge()`, so set it via the direct setter after construction.
+        // Avoid a synthetic second merge only for the single-options-object stream form.
+        const requestUrl = isStream && is.plainObject(url) ? cloneWithProperty(url, 'isStream', true) : url;
+        const requestOptions = isStream && !is.plainObject(url) && options ? cloneWithProperty(options, 'isStream', true) : options;
+        const request = new Request(requestUrl, requestOptions, defaultOptions);
+        if (isStream && request.options) {
+            request.options.isStream = true;
+        }
         let promise;
         const lastHandler = (normalized) => {
             // Note: `options` is `undefined` when `new Options(...)` fails
             request.options = normalized;
-            request._noPipe = !normalized?.isStream;
+            const shouldReturnStream = normalized?.isStream ?? isStream;
+            request._noPipe = !shouldReturnStream;
             void request.flush();
-            if (normalized?.isStream) {
+            if (shouldReturnStream) {
                 return request;
             }
-            promise ||= asPromise(request);
+            promise ??= asPromise(request);
             return promise;
         };
         let iteration = 0;
@@ -43,7 +72,7 @@ const create = (defaults) => {
             const handler = defaults.handlers[iteration++] ?? lastHandler;
             const result = handler(newOptions, iterateHandlers);
             if (is.promise(result) && !request.options?.isStream) {
-                promise ||= asPromise(request);
+                promise ??= asPromise(request);
                 if (result !== promise) {
                     const descriptors = Object.getOwnPropertyDescriptors(promise);
                     for (const key in descriptors) {
@@ -54,13 +83,14 @@ const create = (defaults) => {
                     }
                     // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     Object.defineProperties(result, descriptors);
-                    result.cancel = promise.cancel;
                 }
             }
             return result;
         };
         return iterateHandlers(request.options);
-    });
+    };
+    // Got interface
+    const got = ((url, options, defaultOptions = defaults.options) => makeRequest(url, options, defaultOptions, false));
     got.extend = (...instancesOrOptions) => {
         const options = new Options(undefined, undefined, defaults.options);
         const handlers = [...defaults.handlers];
@@ -72,6 +102,7 @@ const create = (defaults) => {
                 mutableDefaults = value.defaults.mutableDefaults;
             }
             else {
+                assertNoUrlInOptionsObject(value);
                 options.merge(value);
                 if (value.handlers) {
                     handlers.push(...value.handlers);
@@ -87,6 +118,12 @@ const create = (defaults) => {
     };
     // Pagination
     const paginateEach = (async function* (url, options) {
+        if (is.plainObject(url)) {
+            assertNoUrlInOptionsObject(url);
+        }
+        if (is.plainObject(options)) {
+            assertNoUrlInOptionsObject(options);
+        }
         let normalizedOptions = new Options(url, options, defaults.options);
         normalizedOptions.resolveBodyOnly = false;
         const { pagination } = normalizedOptions;
@@ -126,21 +163,41 @@ const create = (defaults) => {
                     }
                 }
             }
-            const optionsToMerge = pagination.paginate({
-                response,
-                currentItems,
-                allItems,
-            });
+            const requestOptions = response.request.options;
+            const previousUrl = requestOptions.url ? new URL(requestOptions.url) : undefined;
+            const previousState = previousUrl ? snapshotCrossOriginState(requestOptions) : undefined;
+            // eslint-disable-next-line no-await-in-loop
+            const [optionsToMerge, changedState] = await requestOptions.trackStateMutations(async (changedState) => [
+                pagination.paginate({
+                    response,
+                    currentItems,
+                    allItems,
+                }),
+                changedState,
+            ]);
             if (optionsToMerge === false) {
                 return;
             }
             if (optionsToMerge === response.request.options) {
                 normalizedOptions = response.request.options;
+                if (previousUrl) {
+                    const nextUrl = normalizedOptions.url;
+                    if (nextUrl && !isSameOrigin(previousUrl, nextUrl)) {
+                        normalizedOptions.prefixUrl = '';
+                        normalizedOptions.stripUnchangedCrossOriginState(previousState, changedState);
+                    }
+                }
             }
             else {
+                const hasExplicitBody = (Object.hasOwn(optionsToMerge, 'body') && optionsToMerge.body !== undefined)
+                    || (Object.hasOwn(optionsToMerge, 'json') && optionsToMerge.json !== undefined)
+                    || (Object.hasOwn(optionsToMerge, 'form') && optionsToMerge.form !== undefined);
+                if (hasExplicitBody) {
+                    normalizedOptions.clearBody();
+                }
                 normalizedOptions.merge(optionsToMerge);
                 try {
-                    assert.any([is.urlInstance, is.undefined], optionsToMerge.url);
+                    assert.any([is.string, is.urlInstance, is.undefined], optionsToMerge.url);
                 }
                 catch (error) {
                     if (error instanceof Error) {
@@ -149,29 +206,28 @@ const create = (defaults) => {
                     throw error;
                 }
                 if (optionsToMerge.url !== undefined) {
-                    normalizedOptions.prefixUrl = '';
-                    normalizedOptions.url = optionsToMerge.url;
+                    const nextUrl = applyUrlOverride(normalizedOptions, optionsToMerge.url, optionsToMerge);
+                    if (previousUrl) {
+                        normalizedOptions.stripSensitiveHeaders(previousUrl, nextUrl, optionsToMerge);
+                        if (!isSameOrigin(previousUrl, nextUrl) && !hasExplicitBody) {
+                            normalizedOptions.clearBody();
+                        }
+                    }
                 }
             }
             numberOfRequests++;
         }
     });
     got.paginate = paginateEach;
-    got.paginate.all = (async (url, options) => {
-        const results = [];
-        for await (const item of paginateEach(url, options)) {
-            results.push(item);
-        }
-        return results;
-    });
+    got.paginate.all = (async (url, options) => Array.fromAsync(paginateEach(url, options)));
     // For those who like very descriptive names
     got.paginate.each = paginateEach;
     // Stream API
-    got.stream = ((url, options) => got(url, { ...options, isStream: true }));
+    got.stream = ((url, options) => makeRequest(url, options, defaults.options, true));
     // Shortcuts
     for (const method of aliases) {
         got[method] = ((url, options) => got(url, { ...options, method }));
-        got.stream[method] = ((url, options) => got(url, { ...options, method, isStream: true }));
+        got.stream[method] = ((url, options) => makeRequest(url, { ...options, method }, defaults.options, true));
     }
     if (!defaults.mutableDefaults) {
         Object.freeze(defaults.handlers);

package/dist/source/index.d.ts

@@ -1,6 +1,5 @@
 declare const got: import("./types.js").Got;
 export default got;
-export { got };
 export { default as Options } from './core/options.js';
 export * from './core/options.js';
 export * from './core/response.js';
@@ -10,7 +9,7 @@ export * from './core/errors.js';
 export * from './core/diagnostics-channel.js';
 export type { Delays } from './core/timed-out.js';
 export { default as calculateRetryDelay } from './core/calculate-retry-delay.js';
-export * from './as-promise/types.js';
-export * from './types.js';
+export type * from './as-promise/types.js';
+export type * from './types.js';
 export { default as create } from './create.js';
 export { default as parseLinkHeader } from './core/parse-link-header.js';

package/dist/source/index.js

@@ -7,8 +7,6 @@ const defaults = {
 };
 const got = create(defaults);
 export default got;
-// TODO: Remove this in the next major version.
-export { got };
 export { default as Options } from './core/options.js';
 export * from './core/options.js';
 export * from './core/response.js';
@@ -16,7 +14,5 @@ export * from './core/index.js';
 export * from './core/errors.js';
 export * from './core/diagnostics-channel.js';
 export { default as calculateRetryDelay } from './core/calculate-retry-delay.js';
-export * from './as-promise/types.js';
-export * from './types.js';
 export { default as create } from './create.js';
 export { default as parseLinkHeader } from './core/parse-link-header.js';