@depup/got 15.0.1-depup.1 → 16.0.0-depup.0

package/README.md

@@ -13,17 +13,18 @@ npm install @depup/got
 
 | Field | Value |
 |-------|-------|
-| Original | [got](https://www.npmjs.com/package/got) @ 15.0.1 |
-| Processed | 2026-04-09 |
+| Original | [got](https://www.npmjs.com/package/got) @ 16.0.0 |
+| Processed | 2026-08-31 |
 | Smoke test | passed |
-| Deps updated | 2 |
+| Deps updated | 3 |
 
 ## Dependency Changes
 
 | Dependency | From | To |
 |------------|------|-----|
-| @sindresorhus/is | ^7.2.0 | ^8.0.0 |
-| type-fest | ^5.4.4 | ^5.5.0 |
+| @sindresorhus/is | ^8.0.0 | ^8.1.0 |
+| cacheable-request | ^13.0.18 | ^13.0.19 |
+| type-fest | ^5.6.0 | ^5.9.0 |
 
 ---
 

package/changes.json

@@ -1,14 +1,18 @@
 {
   "bumped": {
     "@sindresorhus/is": {
-      "from": "^7.2.0",
-      "to": "^8.0.0"
+      "from": "^8.0.0",
+      "to": "^8.1.0"
+    },
+    "cacheable-request": {
+      "from": "^13.0.18",
+      "to": "^13.0.19"
     },
     "type-fest": {
-      "from": "^5.4.4",
-      "to": "^5.5.0"
+      "from": "^5.6.0",
+      "to": "^5.9.0"
     }
   },
-  "timestamp": "2026-04-09T16:40:33.793Z",
-  "totalUpdated": 2
+  "timestamp": "2026-08-31T00:36:02.619Z",
+  "totalUpdated": 3
 }

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

@@ -4,7 +4,7 @@ import { HTTPError, RetryError, } from '../core/errors.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 { applyUrlOverride, isSameOrigin, snapshotCrossOriginState, } from '../core/options.js';
+import { applyUrlOverride, assertUrlHasSameOriginAsPrefixUrlIfNeeded, getUrlPrefixBoundary, hasUrlOrPrefixUrlBoundaryChanged, isSameOrigin, snapshotCrossOriginState, } from '../core/options.js';
 const compressedEncodings = new Set(['gzip', 'deflate', 'br', 'zstd']);
 const proxiedRequestEvents = [
     'request',
@@ -56,6 +56,7 @@ export default function asPromise(firstRequest) {
                         const hooks = options.hooks.afterResponse;
                         for (const [index, hook] of hooks.entries()) {
                             const previousUrl = options.url ? new URL(options.url) : undefined;
+                            const previousBoundary = getUrlPrefixBoundary(options);
                             const previousState = previousUrl ? snapshotCrossOriginState(options) : undefined;
                             const requestOptions = response.request.options;
                             const responseSnapshot = response;
@@ -69,13 +70,36 @@ export default function asPromise(firstRequest) {
                                     : (Object.hasOwn(updatedOptions, 'body') && updatedOptions.body !== undefined)
                                         || (Object.hasOwn(updatedOptions, 'json') && updatedOptions.json !== undefined)
                                         || (Object.hasOwn(updatedOptions, 'form') && updatedOptions.form !== undefined);
+                                const clearsCookieJar = Object.hasOwn(updatedOptions, 'cookieJar') && updatedOptions.cookieJar === undefined;
                                 if (hasExplicitBody && !reusesRequestOptions) {
                                     options.clearBody();
                                 }
+                                if (!reusesRequestOptions && clearsCookieJar) {
+                                    options.cookieJar = undefined;
+                                }
                                 if (!reusesRequestOptions) {
-                                    options.merge(updatedOptions);
+                                    const { url, ...updatedOptionsWithoutUrl } = updatedOptions;
+                                    options.merge(updatedOptionsWithoutUrl);
+                                    options.syncCookieHeaderAfterMerge(previousState, updatedOptionsWithoutUrl.headers);
+                                }
+                                options.clearUnchangedCookieHeader(previousState, reusesRequestOptions ? changedState : undefined);
+                                const currentUrl = options.url;
+                                if (previousUrl
+                                    && currentUrl instanceof URL
+                                    && hasUrlOrPrefixUrlBoundaryChanged(options, currentUrl, previousBoundary)) {
+                                    assertUrlHasSameOriginAsPrefixUrlIfNeeded(options, currentUrl);
                                 }
-                                if (updatedOptions.url) {
+                                if (!reusesRequestOptions
+                                    && updatedOptions.url === undefined
+                                    && previousUrl
+                                    && currentUrl instanceof URL
+                                    && !isSameOrigin(previousUrl, currentUrl)) {
+                                    options.stripSensitiveHeaders(previousUrl, currentUrl, updatedOptions);
+                                    if (!hasExplicitBody) {
+                                        options.clearBody();
+                                    }
+                                }
+                                if (updatedOptions.url !== undefined) {
                                     const nextUrl = reusesRequestOptions
                                         ? options.url
                                         : applyUrlOverride(options, updatedOptions.url, updatedOptions);
@@ -137,7 +161,7 @@ export default function asPromise(firstRequest) {
                 if (error instanceof HTTPError && !options.throwHttpErrors) {
                     const { response } = error;
                     request.destroy();
-                    resolve(request.options.resolveBodyOnly ? response.body : response);
+                    resolve(options.resolveBodyOnly ? response.body : response);
                     return;
                 }
                 reject(error);

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

@@ -13,7 +13,7 @@ const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter, co
     }
     if (error.response) {
         if (retryAfter) {
-            // In this case `computedValue` is `options.request.timeout`
+            // In this case `computedValue` is `retryOptions.maxRetryAfter ?? options.timeout.request ?? Infinity`
             return retryAfter > computedValue ? 0 : retryAfter;
         }
         if (error.response.statusCode === 413) {

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

@@ -99,16 +99,20 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     private _request?;
     private _responseSize?;
     private _bodySize?;
+    private _nativeFormDataBody?;
     private _unproxyEvents?;
     private _triggerRead;
     private readonly _jobs;
     private _cancelTimeouts?;
-    private readonly _abortListenerDisposer?;
+    private _abortListenerDisposer?;
     private _flushed;
     private _aborted;
     private _expectedContentLength?;
     private _compressedBytesCount?;
     private _skipRequestEndInFinal;
+    private _hasWrittenBody;
+    private _hasWritableBody;
+    private _discardBodyWrites;
     private _incrementalDecode?;
     private readonly _requestId;
     private _requestInitialized;
@@ -123,6 +127,8 @@ export default class Request extends Duplex implements RequestEvents<Request> {
         end?: boolean;
     }): T;
     unpipe<T extends NodeJS.WritableStream>(destination: T): this;
+    private _attachAbortListener;
+    private _destroyInFlightAlpnSocket;
     private _shouldIncrementallyDecodeBody;
     private _checkContentLengthMismatch;
     private _finalizeBody;
@@ -139,7 +145,12 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     private _endWritableRequest;
     private _stripCrossOriginState;
     private _stripUnchangedCrossOriginState;
+    private get _methodCanHaveBody();
+    private _canWriteBody;
+    private _hasBodyForRedirect;
+    private _hasUnchangedBodyForRedirect;
     private _dropBody;
+    private _destroyBody;
     private readonly _onBodyError;
     private _writeChunksToRequest;
     private _prepareCache;