got 10.6.0 → 10.7.0

package/dist/source/create.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Merge } from 'type-fest';
+import { Merge, Except } from 'type-fest';
 import { ProxyStream } from './as-stream';
 import * as errors from './errors';
 import { CancelableRequest, Defaults, ExtendOptions, HandlerFunction, NormalizedOptions, Options, Response, URLOrOptions, PaginationOptions } from './types';
@@ -51,9 +51,11 @@ export interface GotRequestMethod {
         isStream: true;
     }>): ProxyStream<T>;
 }
+export declare type GotPaginateOptions<T> = Except<Options, keyof PaginationOptions<unknown>> & PaginationOptions<T>;
+export declare type URLOrGotPaginateOptions<T> = string | GotPaginateOptions<T>;
 export interface GotPaginate {
-    <T>(url: URLOrOptions & PaginationOptions<T>, options?: Options & PaginationOptions<T>): AsyncIterableIterator<T>;
-    all<T>(url: URLOrOptions & PaginationOptions<T>, options?: Options & PaginationOptions<T>): Promise<T[]>;
+    <T>(url: URLOrGotPaginateOptions<T>, options?: GotPaginateOptions<T>): AsyncIterableIterator<T>;
+    all<T>(url: URLOrGotPaginateOptions<T>, options?: GotPaginateOptions<T>): Promise<T[]>;
 }
 export interface Got extends Record<HTTPAlias, GotRequestMethod>, GotRequestMethod {
     stream: GotStream;

package/dist/source/create.js

@@ -111,19 +111,21 @@ const create = (defaults) => {
             const result = await got(normalizedOptions);
             // eslint-disable-next-line no-await-in-loop
             const parsed = await pagination.transform(result);
+            const current = [];
             for (const item of parsed) {
-                if (pagination.filter(item, all)) {
-                    if (!pagination.shouldContinue(item, all)) {
+                if (pagination.filter(item, all, current)) {
+                    if (!pagination.shouldContinue(item, all, current)) {
                         return;
                     }
                     yield item;
                     all.push(item);
+                    current.push(item);
                     if (all.length === pagination.countLimit) {
                         return;
                     }
                 }
             }
-            const optionsToMerge = pagination.paginate(result);
+            const optionsToMerge = pagination.paginate(result, all, current);
             if (optionsToMerge === false) {
                 return;
             }

package/dist/source/index.js

@@ -72,6 +72,9 @@ const defaults = {
         context: {},
         _pagination: {
             transform: (response) => {
+                if (response.request.options.responseType === 'json') {
+                    return response.body;
+                }
                 return JSON.parse(response.body);
             },
             paginate: response => {

package/dist/source/types.d.ts

@@ -104,9 +104,9 @@ export declare type DefaultOptions = Merge<Required<Except<GotOptions, 'hooks' |
 export interface PaginationOptions<T> {
     _pagination?: {
         transform?: (response: Response) => Promise<T[]> | T[];
-        filter?: (item: T, allItems: T[]) => boolean;
-        paginate?: (response: Response) => Options | false;
-        shouldContinue?: (item: T, allItems: T[]) => boolean;
+        filter?: (item: T, allItems: T[], currentItems: T[]) => boolean;
+        paginate?: (response: Response, allItems: T[], currentItems: T[]) => Options | false;
+        shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
         countLimit?: number;
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "10.6.0",
+	"version": "10.7.0",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -94,7 +94,6 @@
 	"types": "dist/source",
 	"sideEffects": false,
 	"browser": {
-		"decompress-response": false,
 		"electron": false
 	},
 	"ava": {

package/readme.md

@@ -190,13 +190,16 @@ Type: `string | Buffer | stream.Readable` or [`form-data` instance](https://gith
 
 **Note #3:** If you provide a payload with the `GET` or `HEAD` method, it will throw a `TypeError` unless the method is `GET` and the `allowGetBody` option is set to `true`.
 
+**Note #4:** This option is not enumerable and will not be merged with the instance defaults.
+
 The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / `fs.createReadStream` instance / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
 
 ###### json
 
 Type: `object | Array | number | string | boolean | null` *(JSON-serializable values)*
 
-**Note:** If you provide this option, `got.stream()` will be read-only.
+**Note #1:** If you provide this option, `got.stream()` will be read-only.
+**Note #2:** This option is not enumerable and will not be merged with the instance defaults.
 
 JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
 
@@ -217,7 +220,7 @@ const instance = got.extend({
 	hooks: {
 		beforeRequest: [
 			options => {
-				if (!options.context && !options.context.token) {
+				if (!options.context || !options.context.token) {
 					throw new Error('Token required');
 				}
 
@@ -248,21 +251,35 @@ Default: `'text'`
 
 The parsing method. Can be `'text'`, `'json'` or `'buffer'`.
 
-The promise also has `.text()`, `.json()` and `.buffer()` methods which sets this and the `resolveBodyOnly` option automatically.
+The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.\
+It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
 
 Example:
 
+```js
+(async () => {
+	const responsePromise = got(url);
+	const bufferPromise = responsePromise.buffer();
+	const jsonPromise = responsePromise.json();
+
+	const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
+	// `response` is an instance of Got Response
+	// `buffer` is an instance of Buffer
+	// `json` is an object
+})();
+```
+
 ```js
 // This
 const body = await got(url).json();
 
-// is the same as this
+// is semantically the same as this
 const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
 ```
 
 ###### resolveBodyOnly
 
-Type: `string`\
+Type: `boolean`\
 Default: `false`
 
 When set to `true` the promise will return the [Response body](#body-1) instead of the [Response](#response) object.
@@ -307,7 +324,8 @@ To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set [`respo
 
 Type: `object | true`
 
-**Note:** If you provide this option, `got.stream()` will be read-only.
+**Note #1:** If you provide this option, `got.stream()` will be read-only.
+**Note #2:** This option is not enumerable and will not be merged with the instance defaults.
 
 The form body is converted to query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
 
@@ -560,7 +578,7 @@ got.post('https://example.com', {
 	hooks: {
 		beforeRetry: [
 			(options, error, retryCount) => {
-				if (error.statusCode === 413) { // Payload too large
+				if (error.response.statusCode === 413) { // Payload too large
 					options.body = getNewBody();
 				}
 			}
@@ -636,7 +654,7 @@ got('https://api.github.com/some-endpoint', {
 				const {response} = error;
  				if (response && response.body) {
 					error.name = 'GitHubError';
-					error.message = `${response.body.message} (${error.statusCode})`;
+					error.message = `${response.body.message} (${response.statusCode})`;
 				}
 
  				return error;
@@ -664,23 +682,64 @@ A function that transform [`Response`](#response) into an array of items. This i
 Type: `Function`\
 Default: [`Link` header logic](source/index.ts)
 
-A function that returns an object representing Got options pointing to the next page. If there are no more pages, `false` should be returned.
+The function takes three arguments:
+- `response` - The current response object.
+- `allItems` - An array of the emitted items.
+- `currentItems` - Items from the current response.
+
+It should return an object representing Got options pointing to the next page. If there are no more pages, `false` should be returned.
+
+For example, if you want to stop when the response contains less items than expected, you can use something like this:
+
+```js
+const got = require('got');
+
+(async () => {
+	const limit = 10;
+
+	const items = got.paginate('https://example.com/items', {
+		searchParams: {
+			limit,
+			offset: 0
+		},
+		_pagination: {
+			paginate: (response, allItems, currentItems) => {
+				const previousSearchParams = response.request.options.searchParams;
+				const {offset: previousOffset} = previousSearchParams;
+
+				if (currentItems.length < limit) {
+					return false;
+				}
+
+				return {
+					searchParams: {
+						...previousSearchParams,
+						offset: previousOffset + limit,
+					}
+				};
+			}
+		}
+	});
+
+	console.log('Items from all pages:', items);
+})();
+```
 
 ###### \_pagination.filter
 
 Type: `Function`\
-Default: `(item, allItems) => true`
+Default: `(item, allItems, currentItems) => true`
 
 Checks whether the item should be emitted or not.
 
 ###### \_pagination.shouldContinue
 
 Type: `Function`\
-Default: `(item, allItems) => true`
+Default: `(item, allItems, currentItems) => true`
 
 Checks whether the pagination should continue.
 
-For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems) => !item.flag`. If you want to stop **after** emitting the entry, you should use `(item, allItems) => allItems.some(entry => entry.flag)` instead.
+For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems, currentItems) => !item.flag`. If you want to stop **after** emitting the entry, you should use `(item, allItems, currentItems) => allItems.some(entry => entry.flag)` instead.
 
 ###### \_pagination.countLimit
 
@@ -1012,6 +1071,14 @@ Options are deeply merged to a new object. The value of each key is determined a
 	- If the parent property is a plain `object` too, both values are merged recursively into a new `object`.
 	- Otherwise, only the new value is deeply cloned.
 - If the new property is an `Array`, it overwrites the old one with a deep clone of the new property.
+- Properties that are not enumerable, such as `context`, `body`, `json`, and `form`, will not be merged.
+```js
+const a = {json: {cat: 'meow'}};
+const b = {json: {cow: 'moo'}};
+
+got.mergeOptions(a, b);
+//=> {json: {cow: 'moo'}}
+```
 - Otherwise, the new value is assigned to the key.
 
 #### got.defaults