got 10.5.7 → 11.0.0

package/dist/source/types.d.ts

@@ -1,208 +1,94 @@
 /// <reference types="node" />
-import http = require('http');
-import https = require('https');
-import Keyv = require('keyv');
-import CacheableRequest = require('cacheable-request');
-import PCancelable = require('p-cancelable');
-import ResponseLike = require('responselike');
 import { URL } from 'url';
-import { Readable as ReadableStream } from 'stream';
-import { Timings, IncomingMessageWithTimings } from '@szmarczak/http-timer';
-import CacheableLookup from 'cacheable-lookup';
-import { Except, Merge } from 'type-fest';
-import { GotReturn } from './create';
-import { GotError, HTTPError, MaxRedirectsError, ParseError, TimeoutError, RequestError } from './errors';
-import { Hooks } from './known-hook-events';
-import { URLOptions } from './utils/options-to-url';
-export declare type GeneralError = Error | GotError | HTTPError | MaxRedirectsError | ParseError;
-export declare type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'HEAD' | 'DELETE' | 'OPTIONS' | 'TRACE' | 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'trace';
-export declare type ResponseType = 'json' | 'buffer' | 'text';
-export interface Response<BodyType = unknown> extends IncomingMessageWithTimings {
-    body: BodyType;
-    statusCode: number;
-    /**
-    The remote IP address.
-
-    Note: Not available when the response is cached. This is hopefully a temporary limitation, see [lukechilds/cacheable-request#86](https://github.com/lukechilds/cacheable-request/issues/86).
-    */
-    ip: string;
-    fromCache?: boolean;
-    isFromCache?: boolean;
-    req?: http.ClientRequest;
-    requestUrl: string;
-    retryCount: number;
-    timings: Timings;
-    redirectUrls: string[];
-    request: {
-        options: NormalizedOptions;
-    };
-    url: string;
-}
-export interface ResponseObject extends Partial<ResponseLike> {
-    socket: {
-        remoteAddress: string;
-    };
-}
-export interface RetryObject {
-    attemptCount: number;
-    retryOptions: Required<RetryOptions>;
-    error: TimeoutError | RequestError;
-    computedValue: number;
-}
-export declare type RetryFunction = (retryObject: RetryObject) => number;
-export declare type HandlerFunction = <T extends GotReturn>(options: NormalizedOptions, next: (options: NormalizedOptions) => T) => T | Promise<T>;
-export interface DefaultRetryOptions {
-    limit: number;
-    methods: Method[];
-    statusCodes: number[];
-    errorCodes: string[];
-    calculateDelay: RetryFunction;
-    maxRetryAfter?: number;
-}
-export interface RetryOptions extends Partial<DefaultRetryOptions> {
-    retries?: number;
-}
-export declare type RequestFunction = typeof http.request;
-export interface AgentByProtocol {
-    http?: http.Agent;
-    https?: https.Agent;
-}
-export interface Delays {
-    lookup?: number;
-    connect?: number;
-    secureConnect?: number;
-    socket?: number;
-    response?: number;
-    send?: number;
-    request?: number;
-}
-export declare type Headers = Record<string, string | string[] | undefined>;
-interface ToughCookieJar {
-    getCookieString(currentUrl: string, options: {
-        [key: string]: unknown;
-    }, cb: (err: Error | null, cookies: string) => void): void;
-    getCookieString(url: string, callback: (error: Error | null, cookieHeader: string) => void): void;
-    setCookie(cookieOrString: unknown, currentUrl: string, options: {
-        [key: string]: unknown;
-    }, cb: (err: Error | null, cookie: unknown) => void): void;
-    setCookie(rawCookie: string, url: string, callback: (error: Error | null, result: unknown) => void): void;
-}
-interface PromiseCookieJar {
-    getCookieString(url: string): Promise<string>;
-    setCookie(rawCookie: string, url: string): Promise<unknown>;
-}
-export declare const requestSymbol: unique symbol;
-export declare type DefaultOptions = Merge<Required<Except<GotOptions, 'hooks' | 'retry' | 'timeout' | 'context' | '_pagination' | 'agent' | 'body' | 'cookieJar' | 'encoding' | 'form' | 'json' | 'lookup' | 'request' | 'url' | typeof requestSymbol>>, {
-    hooks: Required<Hooks>;
-    retry: DefaultRetryOptions;
-    timeout: Delays;
-    context: {
-        [key: string]: any;
-    };
-    _pagination?: PaginationOptions<unknown>['_pagination'];
-}>;
-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;
-        countLimit?: number;
-    };
-}
-export interface GotOptions extends PaginationOptions<unknown> {
-    [requestSymbol]?: RequestFunction;
-    url?: URL | string;
-    body?: string | Buffer | ReadableStream;
-    hooks?: Hooks;
-    decompress?: boolean;
-    isStream?: boolean;
-    encoding?: BufferEncoding;
-    method?: Method;
-    retry?: RetryOptions | number;
-    throwHttpErrors?: boolean;
-    cookieJar?: ToughCookieJar | PromiseCookieJar;
-    ignoreInvalidCookies?: boolean;
-    request?: RequestFunction;
-    agent?: http.Agent | https.Agent | boolean | AgentByProtocol;
-    cache?: string | CacheableRequest.StorageAdapter | false;
-    headers?: Headers;
-    responseType?: ResponseType;
-    resolveBodyOnly?: boolean;
-    followRedirect?: boolean;
-    prefixUrl?: URL | string;
-    timeout?: number | Delays;
-    dnsCache?: CacheableLookup | Map<string, string> | Keyv | false;
-    useElectronNet?: boolean;
-    form?: {
-        [key: string]: any;
-    };
-    json?: {
-        [key: string]: any;
-    };
-    context?: {
-        [key: string]: any;
-    };
-    maxRedirects?: number;
-    lookup?: CacheableLookup['lookup'];
-    methodRewriting?: boolean;
-}
-export declare type Options = Merge<https.RequestOptions, Merge<GotOptions, URLOptions>>;
-export interface NormalizedOptions extends Options {
-    headers: Headers;
-    hooks: Required<Hooks>;
-    timeout: Delays;
-    dnsCache: CacheableLookup | false;
-    lookup?: CacheableLookup['lookup'];
-    retry: Required<RetryOptions>;
-    prefixUrl: string;
-    method: Method;
-    url: URL;
-    cacheableRequest?: (options: string | URL | http.RequestOptions, callback?: (response: http.ServerResponse | ResponseLike) => void) => CacheableRequest.Emitter;
-    cookieJar?: PromiseCookieJar;
-    maxRedirects: number;
-    pagination?: Required<PaginationOptions<unknown>['_pagination']>;
-    [requestSymbol]: RequestFunction;
-    decompress: boolean;
-    isStream: boolean;
-    throwHttpErrors: boolean;
-    ignoreInvalidCookies: boolean;
-    cache: CacheableRequest.StorageAdapter | false;
-    responseType: ResponseType;
-    resolveBodyOnly: boolean;
-    followRedirect: boolean;
-    useElectronNet: boolean;
-    methodRewriting: boolean;
-    context: {
-        [key: string]: any;
-    };
-    path?: string;
-}
-export interface ExtendOptions extends Options {
-    handlers?: HandlerFunction[];
-    mutableDefaults?: boolean;
-}
-export interface Defaults {
+import { CancelError } from 'p-cancelable';
+import { CancelableRequest, Response, Options, NormalizedOptions, Defaults as DefaultOptions, PaginationOptions, ParseError, RequestError, CacheError, ReadError, HTTPError, MaxRedirectsError, TimeoutError } from './as-promise';
+import Request from './core';
+declare type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
+declare type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
+export interface InstanceDefaults {
     options: DefaultOptions;
     handlers: HandlerFunction[];
     mutableDefaults: boolean;
     _rawHandlers?: HandlerFunction[];
 }
-export declare type URLOrOptions = Options | string;
-export interface Progress {
-    percent: number;
-    transferred: number;
-    total?: number;
-}
-export interface GotEvents<T> {
-    on(name: 'request', listener: (request: http.ClientRequest) => void): T;
-    on(name: 'response', listener: (response: Response) => void): T;
-    on(name: 'redirect', listener: (response: Response, nextOptions: NormalizedOptions) => void): T;
-    on(name: 'uploadProgress' | 'downloadProgress', listener: (progress: Progress) => void): T;
+export declare type GotReturn = Request | CancelableRequest;
+export declare type HandlerFunction = <T extends GotReturn>(options: NormalizedOptions, next: (options: NormalizedOptions) => T) => T | Promise<T>;
+export interface ExtendOptions extends Options {
+    handlers?: HandlerFunction[];
+    mutableDefaults?: boolean;
 }
-export interface CancelableRequest<T extends Response | Response['body']> extends PCancelable<T>, GotEvents<CancelableRequest<T>> {
-    json<ReturnType>(): CancelableRequest<ReturnType>;
-    buffer(): CancelableRequest<Buffer>;
-    text(): CancelableRequest<string>;
+export declare type OptionsOfTextResponseBody = Options & {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType?: 'text';
+};
+export declare type OptionsOfJSONResponseBody = Options & {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType: 'json';
+};
+export declare type OptionsOfBufferResponseBody = Options & {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType: 'buffer';
+};
+export declare type StrictOptions = Except<Options, 'isStream' | 'responseType' | 'resolveBodyOnly'>;
+declare type ResponseBodyOnly = {
+    resolveBodyOnly: true;
+};
+export declare type OptionsWithPagination<T = unknown> = Merge<Options, PaginationOptions<T>>;
+export interface GotPaginate {
+    <T>(url: string | URL, options?: OptionsWithPagination<T>): AsyncIterableIterator<T>;
+    all<T>(url: string | URL, options?: OptionsWithPagination<T>): Promise<T[]>;
+    <T>(options?: OptionsWithPagination<T>): AsyncIterableIterator<T>;
+    all<T>(options?: OptionsWithPagination<T>): Promise<T[]>;
+}
+export interface GotRequestFunction {
+    (url: string | URL, options?: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
+    <T>(url: string | URL, options?: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;
+    (url: string | URL, options?: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
+    (options: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
+    <T>(options: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;
+    (options: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
+    (url: string | URL, options?: (OptionsOfTextResponseBody & ResponseBodyOnly)): CancelableRequest<string>;
+    <T>(url: string | URL, options?: (OptionsOfJSONResponseBody & ResponseBodyOnly)): CancelableRequest<T>;
+    (url: string | URL, options?: (OptionsOfBufferResponseBody & ResponseBodyOnly)): CancelableRequest<Buffer>;
+    (options: (OptionsOfTextResponseBody & ResponseBodyOnly)): CancelableRequest<string>;
+    <T>(options: (OptionsOfJSONResponseBody & ResponseBodyOnly)): CancelableRequest<T>;
+    (options: (OptionsOfBufferResponseBody & ResponseBodyOnly)): CancelableRequest<Buffer>;
+    (url: string | URL, options?: Options & {
+        isStream: true;
+    }): Request;
+    (options: Options & {
+        isStream: true;
+    }): Request;
+    (url: string | URL, options?: Options): CancelableRequest | Request;
+    (options: Options): CancelableRequest | Request;
+}
+export declare type HTTPAlias = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
+interface GotStreamFunction {
+    (url: string | URL, options?: Options & {
+        isStream?: true;
+    }): Request;
+    (options?: Options & {
+        isStream?: true;
+    }): Request;
+}
+export declare type GotStream = GotStreamFunction & Record<HTTPAlias, GotStreamFunction>;
+export interface Got extends Record<HTTPAlias, GotRequestFunction>, GotRequestFunction {
+    stream: GotStream;
+    paginate: GotPaginate;
+    defaults: InstanceDefaults;
+    CacheError: typeof CacheError;
+    RequestError: typeof RequestError;
+    ReadError: typeof ReadError;
+    ParseError: typeof ParseError;
+    HTTPError: typeof HTTPError;
+    MaxRedirectsError: typeof MaxRedirectsError;
+    TimeoutError: typeof TimeoutError;
+    CancelError: typeof CancelError;
+    extend(...instancesOrOptions: Array<Got | ExtendOptions>): Got;
+    mergeInstances(parent: Got, ...instances: Got[]): Got;
+    mergeOptions(...sources: Options[]): NormalizedOptions;
 }
 export {};

package/dist/source/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestSymbol = Symbol('request');

package/package.json

@@ -1,16 +1,16 @@
 {
 	"name": "got",
-	"version": "10.5.7",
+	"version": "11.0.0",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
 	"funding": "https://github.com/sindresorhus/got?sponsor=1",
 	"main": "dist/source",
 	"engines": {
-		"node": ">=10"
+		"node": ">=10.19.0"
 	},
 	"scripts": {
-		"test": "xo && tsc --noEmit && nyc ava",
+		"test": "xo && tsc --noEmit && nyc --reporter=html --reporter=text ava",
 		"release": "np",
 		"build": "del-cli dist && tsc",
 		"prepare": "npm run build"
@@ -33,70 +33,68 @@
 		"fetch",
 		"net",
 		"network",
-		"electron",
+		"gzip",
 		"brotli",
 		"requests",
 		"human-friendly",
 		"axios",
-		"superagent"
+		"superagent",
+		"node-fetch",
+		"ky"
 	],
 	"dependencies": {
-		"@sindresorhus/is": "^2.0.0",
+		"@sindresorhus/is": "^2.1.0",
 		"@szmarczak/http-timer": "^4.0.0",
 		"@types/cacheable-request": "^6.0.1",
-		"cacheable-lookup": "^2.0.0",
+		"@types/responselike": "^1.0.0",
+		"cacheable-lookup": "^4.1.1",
 		"cacheable-request": "^7.0.1",
 		"decompress-response": "^5.0.0",
-		"duplexer3": "^0.1.4",
 		"get-stream": "^5.0.0",
+		"http2-wrapper": "^1.0.0-beta.4.3",
 		"lowercase-keys": "^2.0.0",
-		"mimic-response": "^2.0.0",
 		"p-cancelable": "^2.0.0",
-		"p-event": "^4.0.0",
-		"responselike": "^2.0.0",
-		"to-readable-stream": "^2.0.0",
-		"type-fest": "^0.10.0"
+		"responselike": "^2.0.0"
 	},
 	"devDependencies": {
-		"@ava/typescript": "^1.1.0",
+		"@ava/typescript": "^1.1.1",
 		"@sindresorhus/tsconfig": "^0.7.0",
-		"@types/duplexer3": "^0.1.0",
-		"@types/express": "^4.17.2",
+		"@types/benchmark": "^1.0.31",
+		"@types/express": "^4.17.6",
 		"@types/lolex": "^5.1.0",
 		"@types/node": "13.1.2",
-		"@types/proxyquire": "^1.3.28",
-		"@types/sinon": "^7.0.13",
-		"@types/tough-cookie": "^2.3.5",
-		"@typescript-eslint/eslint-plugin": "^2.19.2",
-		"@typescript-eslint/parser": "^2.19.2",
-		"ava": "^3.3.0",
+		"@types/node-fetch": "^2.5.5",
+		"@types/request": "^2.48.4",
+		"@types/sinon": "^9.0.0",
+		"@types/tough-cookie": "^4.0.0",
+		"@typescript-eslint/eslint-plugin": "^2.27.0",
+		"@typescript-eslint/parser": "^2.27.0",
+		"ava": "^3.6.0",
+		"axios": "^0.19.2",
+		"benchmark": "^2.1.4",
 		"coveralls": "^3.0.4",
 		"create-test-server": "^3.0.1",
 		"del-cli": "^3.0.0",
 		"delay": "^4.3.0",
-		"eslint-config-xo-typescript": "^0.26.0",
+		"eslint-config-xo-typescript": "^0.27.0",
 		"express": "^4.17.1",
 		"form-data": "^3.0.0",
-		"get-port": "^5.0.0",
-		"keyv": "^4.0.0",
 		"lolex": "^6.0.0",
-		"nock": "^11.8.2",
+		"nock": "^12.0.0",
+		"node-fetch": "^2.6.0",
 		"np": "^6.0.0",
-		"nyc": "^15.0.0",
-		"proxyquire": "^2.0.1",
-		"sinon": "^8.1.1",
+		"nyc": "^15.0.1",
+		"p-event": "^4.0.0",
+		"sinon": "^9.0.2",
 		"slow-stream": "0.0.4",
-		"tempy": "^0.4.0",
-		"tough-cookie": "^3.0.0",
+		"tempy": "^0.5.0",
+		"to-readable-stream": "^2.1.0",
+		"tough-cookie": "^4.0.0",
 		"typescript": "3.7.5",
-		"xo": "^0.26.0"
+		"xo": "^0.29.0"
 	},
 	"types": "dist/source",
 	"sideEffects": false,
-	"browser": {
-		"decompress-response": false,
-		"electron": false
-	},
 	"ava": {
 		"files": [
 			"test/*"
@@ -126,8 +124,14 @@
 		],
 		"rules": {
 			"@typescript-eslint/no-empty-function": "off",
+			"@typescript-eslint/no-base-to-string": "off",
 			"node/prefer-global/url": "off",
-			"node/prefer-global/url-search-params": "off"
+			"node/prefer-global/url-search-params": "off",
+			"unicorn/string-content": "off",
+			"@typescript-eslint/prefer-readonly-parameter-types": "off",
+			"@typescript-eslint/no-unsafe-member-access": "off",
+			"@typescript-eslint/no-unsafe-call": "off",
+			"@typescript-eslint/no-unsafe-return": "off"
 		}
 	}
 }