Socket
Socket
Sign inDemoInstall

got

Package Overview
Dependencies
Maintainers
2
Versions
176
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

got - npm Package Compare versions

Comparing version 11.8.6 to 14.0.0

dist/source/core/errors.d.ts
dist/source/core/errors.js
dist/source/core/options.d.ts
dist/source/core/options.js
dist/source/core/parse-link-header.d.ts
dist/source/core/parse-link-header.js
dist/source/core/response.d.ts
dist/source/core/response.js
dist/source/core/timed-out.d.ts
dist/source/core/timed-out.js
dist/source/core/utils/is-client-request.d.ts
dist/source/core/utils/is-client-request.js
dist/source/core/utils/is-unix-socket-url.d.ts
dist/source/core/utils/is-unix-socket-url.js

6

dist/source/as-promise/index.d.ts

@@ -1,3 +0,3 @@

import { NormalizedOptions, CancelableRequest } from './types';
export default function asPromise<T>(normalizedOptions: NormalizedOptions): CancelableRequest<T>;
export * from './types';
import Request from '../core/index.js';
import { type CancelableRequest } from './types.js';
export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T>;

160

dist/source/as-promise/index.js

@@ -1,22 +0,9 @@

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const is_1 = require("@sindresorhus/is");
const PCancelable = require("p-cancelable");
const types_1 = require("./types");
const parse_body_1 = require("./parse-body");
const core_1 = require("../core");
const proxy_events_1 = require("../core/utils/proxy-events");
const get_buffer_1 = require("../core/utils/get-buffer");
const is_response_ok_1 = require("../core/utils/is-response-ok");
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 } from '../core/response.js';
import proxyEvents from '../core/utils/proxy-events.js';
import { CancelError } from './types.js';
const proxiedRequestEvents = [

@@ -27,53 +14,42 @@ 'request',

'uploadProgress',
'downloadProgress'
'downloadProgress',
];
function asPromise(normalizedOptions) {
export default function asPromise(firstRequest) {
let globalRequest;
let globalResponse;
const emitter = new events_1.EventEmitter();
let normalizedOptions;
const emitter = new EventEmitter();
const promise = new PCancelable((resolve, reject, onCancel) => {
onCancel(() => {
globalRequest.destroy();
});
onCancel.shouldReject = false;
onCancel(() => {
reject(new CancelError(globalRequest));
});
const makeRequest = (retryCount) => {
const request = new core_1.default(undefined, normalizedOptions);
// 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);
request.retryCount = retryCount;
request._noPipe = true;
onCancel(() => request.destroy());
onCancel.shouldReject = false;
onCancel(() => reject(new types_1.CancelError(request)));
globalRequest = request;
request.once('response', async (response) => {
var _a;
response.retryCount = retryCount;
if (response.request.aborted) {
// Canceled while downloading - will throw a `CancelError` or `TimeoutError` error
return;
}
// Download body
let rawBody;
try {
rawBody = await get_buffer_1.default(request);
response.rawBody = rawBody;
}
catch (_b) {
// The same error is caught below.
// See request.once('error')
return;
}
if (request._isAboutToError) {
return;
}
// Parse body
const contentEncoding = ((_a = response.headers['content-encoding']) !== null && _a !== void 0 ? _a : '').toLowerCase();
const isCompressed = ['gzip', 'deflate', 'br'].includes(contentEncoding);
const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br';
const { options } = request;
if (isCompressed && !options.decompress) {
response.body = rawBody;
response.body = response.rawBody;
}
else {
try {
response.body = parse_body_1.default(response, options.responseType, options.parseJson, options.encoding);
response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
}
catch (error) {
// Fallback to `utf8`
response.body = rawBody.toString();
if (is_response_ok_1.isResponseOk(response)) {
// Fall back to `utf8`
response.body = response.rawBody.toString();
if (isResponseOk(response)) {
request._beforeError(error);

@@ -85,37 +61,29 @@ return;

try {
for (const [index, hook] of options.hooks.afterResponse.entries()) {
const hooks = options.hooks.afterResponse;
for (const [index, hook] of hooks.entries()) {
// @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
// eslint-disable-next-line no-await-in-loop
response = await hook(response, async (updatedOptions) => {
const typedOptions = core_1.default.normalizeArguments(undefined, {
...updatedOptions,
retry: {
calculateDelay: () => 0
},
throwHttpErrors: false,
resolveBodyOnly: false
}, options);
options.merge(updatedOptions);
options.prefixUrl = '';
if (updatedOptions.url) {
options.url = updatedOptions.url;
}
// Remove any further hooks for that request, because we'll call them anyway.
// The loop continues. We don't want duplicates (asPromise recursion).
typedOptions.hooks.afterResponse = typedOptions.hooks.afterResponse.slice(0, index);
for (const hook of typedOptions.hooks.beforeRetry) {
// eslint-disable-next-line no-await-in-loop
await hook(typedOptions);
}
const promise = asPromise(typedOptions);
onCancel(() => {
promise.catch(() => { });
promise.cancel();
});
return promise;
options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
throw new RetryError(request);
});
if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
throw new TypeError('The `afterResponse` hook returned an invalid value');
}
}
}
catch (error) {
request._beforeError(new types_1.RequestError(error.message, error, request));
request._beforeError(error);
return;
}
globalResponse = response;
if (!is_response_ok_1.isResponseOk(response)) {
request._beforeError(new types_1.HTTPError(response));
if (!isResponseOk(response)) {
request._beforeError(new HTTPError(response));
return;

@@ -131,4 +99,5 @@ }

const { options } = request;
if (error instanceof types_1.HTTPError && !options.throwHttpErrors) {
if (error instanceof HTTPError && !options.throwHttpErrors) {
const { response } = error;
request.destroy();
resolve(request.options.resolveBodyOnly ? response.body : response);

@@ -140,12 +109,20 @@ return;

request.once('error', onError);
const previousBody = request.options.body;
const previousBody = request.options?.body;
request.once('retry', (newRetryCount, error) => {
var _a, _b;
if (previousBody === ((_a = error.request) === null || _a === void 0 ? void 0 : _a.options.body) && is_1.default.nodeStream((_b = error.request) === null || _b === void 0 ? void 0 : _b.options.body)) {
firstRequest = undefined;
const newBody = request.options.body;
if (previousBody === newBody && is.nodeStream(newBody)) {
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);
});
proxy_events_1.default(request, emitter, proxiedRequestEvents);
proxyEvents(request, emitter, proxiedRequestEvents);
if (is.undefined(firstRequest)) {
void request.flush();
}
};

@@ -158,2 +135,6 @@ makeRequest(0);

};
promise.off = (event, fn) => {
emitter.off(event, fn);
return promise;
};
const shortcut = (responseType) => {

@@ -164,4 +145,5 @@ const newPromise = (async () => {

const { options } = globalResponse.request;
return parse_body_1.default(globalResponse, responseType, options.parseJson, options.encoding);
return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
})();
// eslint-disable-next-line @typescript-eslint/no-floating-promises
Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));

@@ -171,5 +153,7 @@ return newPromise;

promise.json = () => {
const { headers } = globalRequest.options;
if (!globalRequest.writableFinished && headers.accept === undefined) {
headers.accept = 'application/json';
if (globalRequest.options) {
const { headers } = globalRequest.options;
if (!globalRequest.writableFinished && !('accept' in headers)) {
headers.accept = 'application/json';
}
}

@@ -182,3 +166,1 @@ return shortcut('json');

}
exports.default = asPromise;
__exportStar(require("./types"), exports);

268

dist/source/as-promise/types.d.ts

@@ -1,244 +0,9 @@

/// <reference types="node" />
import PCancelable = require('p-cancelable');
import Request, { Options, Response, RequestError, RequestEvents } from '../core';
/// <reference types="node" resolution-mode="require"/>
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';
/**
All parsing methods supported by Got.
*/
export declare type ResponseType = 'json' | 'buffer' | 'text';
export interface PaginationOptions<T, R> {
/**
All options accepted by `got.paginate()`.
*/
pagination?: {
/**
A function that transform [`Response`](#response) into an array of items.
This is where you should do the parsing.
@default response => JSON.parse(response.body)
*/
transform?: (response: Response<R>) => Promise<T[]> | T[];
/**
Checks whether the item should be emitted or not.
@default (item, allItems, currentItems) => true
*/
filter?: (item: T, allItems: T[], currentItems: T[]) => boolean;
/**
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.
The options are merged automatically with the previous request, therefore the options returned `pagination.paginate(...)` must reflect changes only.
If there are no more pages, `false` should be returned.
@example
```
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 previousOffset = previousSearchParams.get('offset');
if (currentItems.length < limit) {
return false;
}
return {
searchParams: {
...previousSearchParams,
offset: Number(previousOffset) + limit,
}
};
}
}
});
console.log('Items from all pages:', items);
})();
```
*/
paginate?: (response: Response<R>, allItems: T[], currentItems: T[]) => Options | false;
/**
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, currentItems) => !item.flag`.
If you want to stop **after** emitting the entry, you should use `(item, allItems, currentItems) => allItems.some(entry => entry.flag)` instead.
@default (item, allItems, currentItems) => true
*/
shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
/**
The maximum amount of items that should be emitted.
@default Infinity
*/
countLimit?: number;
/**
Milliseconds to wait before the next request is triggered.
@default 0
*/
backoff?: number;
/**
The maximum amount of request that should be triggered.
Retries on failure are not counted towards this limit.
For example, it can be helpful during development to avoid an infinite number of requests.
@default 10000
*/
requestLimit?: number;
/**
Defines how the parameter `allItems` in pagination.paginate, pagination.filter and pagination.shouldContinue is managed.
When set to `false`, the parameter `allItems` is always an empty array.
This option can be helpful to save on memory usage when working with a large dataset.
*/
stackAllItems?: boolean;
};
}
export declare type AfterResponseHook = (response: Response, retryWithMergedOptions: (options: Options) => CancelableRequest<Response>) => Response | CancelableRequest<Response> | Promise<Response | CancelableRequest<Response>>;
export declare namespace PromiseOnly {
interface Hooks {
/**
Called with [response object](#response) and a retry function.
Calling the retry function will trigger `beforeRetry` hooks.
Each function should return the response.
This is especially useful when you want to refresh an access token.
__Note__: When using streams, this hook is ignored.
@example
```
const got = require('got');
const instance = got.extend({
hooks: {
afterResponse: [
(response, retryWithMergedOptions) => {
if (response.statusCode === 401) { // Unauthorized
const updatedOptions = {
headers: {
token: getNewToken() // Refresh the access token
}
};
// Save for further requests
instance.defaults.options = got.mergeOptions(instance.defaults.options, updatedOptions);
// Make a new retry
return retryWithMergedOptions(updatedOptions);
}
// No changes otherwise
return response;
}
],
beforeRetry: [
(options, error, retryCount) => {
// This will be called on `retryWithMergedOptions(...)`
}
]
},
mutableDefaults: true
});
```
*/
afterResponse?: AfterResponseHook[];
}
interface Options extends PaginationOptions<unknown, unknown> {
/**
The parsing method.
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.
__Note__: When using streams, this option is ignored.
@example
```
(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
})();
```
@example
```
// This
const body = await got(url).json();
// is semantically the same as this
const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
```
*/
responseType?: ResponseType;
/**
When set to `true` the promise will return the Response body instead of the Response object.
@default false
*/
resolveBodyOnly?: boolean;
/**
Returns a `Stream` instead of a `Promise`.
This is equivalent to calling `got.stream(url, options?)`.
@default false
*/
isStream?: boolean;
/**
[Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
Don't set this option to `null`.
__Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
@default 'utf-8'
*/
encoding?: BufferEncoding;
}
interface NormalizedOptions {
responseType: ResponseType;
resolveBodyOnly: boolean;
isStream: boolean;
encoding?: BufferEncoding;
pagination?: Required<PaginationOptions<unknown, unknown>['pagination']>;
}
interface Defaults {
responseType: ResponseType;
resolveBodyOnly: boolean;
isStream: boolean;
pagination?: Required<PaginationOptions<unknown, unknown>['pagination']>;
}
type HookEvent = 'afterResponse';
}
/**
An error to be thrown when server response code is 2xx, and parsing body fails.
Includes a `response` property.
*/
export declare class ParseError extends RequestError {
readonly response: Response;
constructor(error: Error, response: Response);
}
/**
An error to be thrown when the request is aborted with `.cancel()`.

@@ -249,9 +14,26 @@ */

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>> {
/**
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'`.
*/
json: <ReturnType>() => CancelableRequest<ReturnType>;
/**
A shortcut method that gives a Promise returning a [Buffer](https://nodejs.org/api/buffer.html).
It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
*/
buffer: () => CancelableRequest<Buffer>;
/**
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'`.
*/
text: () => CancelableRequest<string>;
}
export * from '../core';

35

dist/source/as-promise/types.js

@@ -1,32 +0,6 @@

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CancelError = exports.ParseError = void 0;
const core_1 = require("../core");
import { RequestError } from '../core/errors.js';
/**
An error to be thrown when server response code is 2xx, and parsing body fails.
Includes a `response` property.
*/
class ParseError extends core_1.RequestError {
constructor(error, response) {
const { options } = response.request;
super(`${error.message} in "${options.url.toString()}"`, error, response.request);
this.name = 'ParseError';
this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_BODY_PARSE_FAILURE' : this.code;
}
}
exports.ParseError = ParseError;
/**
An error to be thrown when the request is aborted with `.cancel()`.
*/
class CancelError extends core_1.RequestError {
export class CancelError extends RequestError {
constructor(request) {

@@ -37,2 +11,5 @@ super('Promise was canceled', {}, request);

}
/**
Whether the promise is canceled.
*/
get isCanceled() {

@@ -42,3 +19,1 @@ return true;

}
exports.CancelError = CancelError;
__exportStar(require("../core"), exports);

5

dist/source/core/calculate-retry-delay.d.ts

@@ -1,5 +0,4 @@

import { RetryFunction } from '.';
declare type Returns<T extends (...args: any) => unknown, V> = (...args: Parameters<T>) => V;
export declare const retryAfterStatusCodes: ReadonlySet<number>;
import type { RetryFunction } from './options.js';
type Returns<T extends (...args: any) => unknown, V> = (...args: Parameters<T>) => V;
declare const calculateRetryDelay: Returns<RetryFunction, number>;
export default calculateRetryDelay;

18

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

@@ -1,6 +0,5 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.retryAfterStatusCodes = void 0;
exports.retryAfterStatusCodes = new Set([413, 429, 503]);
const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter }) => {
const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter, computedValue, }) => {
if (error.name === 'RetryError') {
return 1;
}
if (attemptCount > retryOptions.limit) {

@@ -17,3 +16,4 @@ return 0;

if (retryAfter) {
if (retryOptions.maxRetryAfter === undefined || retryAfter > retryOptions.maxRetryAfter) {
// In this case `computedValue` is `options.request.timeout`
if (retryAfter > computedValue) {
return 0;

@@ -27,5 +27,5 @@ }

}
const noise = Math.random() * 100;
return ((2 ** (attemptCount - 1)) * 1000) + noise;
const noise = Math.random() * retryOptions.noise;
return Math.min(((2 ** (attemptCount - 1)) * 1000), retryOptions.backoffLimit) + noise;
};
exports.default = calculateRetryDelay;
export default calculateRetryDelay;

1161

dist/source/core/index.d.ts

@@ -1,1070 +0,140 @@

/// <reference types="node" />
import { Duplex, Readable } from 'stream';
import { URL, URLSearchParams } from 'url';
import { Socket } from 'net';
import { SecureContextOptions, DetailedPeerCertificate } from 'tls';
import http = require('http');
import { ClientRequest, RequestOptions, ServerResponse, request as httpRequest } from 'http';
import https = require('https');
import { Timings, IncomingMessageWithTimings } from '@szmarczak/http-timer';
import CacheableLookup from 'cacheable-lookup';
import CacheableRequest = require('cacheable-request');
import ResponseLike = require('responselike');
import { Delays, TimeoutError as TimedOutTimeoutError } from './utils/timed-out';
import { URLOptions } from './utils/options-to-url';
import { DnsLookupIpVersion } from './utils/dns-ip-version';
import { PromiseOnly } from '../as-promise/types';
declare type HttpRequestFunction = typeof httpRequest;
declare type Error = NodeJS.ErrnoException;
declare const kRequest: unique symbol;
declare const kResponse: unique symbol;
declare const kResponseSize: unique symbol;
declare const kDownloadedSize: unique symbol;
declare const kBodySize: unique symbol;
declare const kUploadedSize: unique symbol;
declare const kServerResponsesPiped: unique symbol;
declare const kUnproxyEvents: unique symbol;
declare const kIsFromCache: unique symbol;
declare const kCancelTimeouts: unique symbol;
declare const kStartedReading: unique symbol;
declare const kStopReading: unique symbol;
declare const kTriggerRead: unique symbol;
declare const kBody: unique symbol;
declare const kJobs: unique symbol;
declare const kOriginalResponse: unique symbol;
declare const kRetryTimeout: unique symbol;
export declare const kIsNormalizedAlready: unique symbol;
export interface Agents {
http?: http.Agent;
https?: https.Agent;
http2?: unknown;
}
export declare const withoutBody: ReadonlySet<string>;
export interface ToughCookieJar {
getCookieString: ((currentUrl: string, options: Record<string, unknown>, cb: (err: Error | null, cookies: string) => void) => void) & ((url: string, callback: (error: Error | null, cookieHeader: string) => void) => void);
setCookie: ((cookieOrString: unknown, currentUrl: string, options: Record<string, unknown>, cb: (err: Error | null, cookie: unknown) => void) => void) & ((rawCookie: string, url: string, callback: (error: Error | null, result: unknown) => void) => void);
}
export interface PromiseCookieJar {
getCookieString: (url: string) => Promise<string>;
setCookie: (rawCookie: string, url: string) => Promise<unknown>;
}
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
import { Duplex } from 'node:stream';
import { type ClientRequest } from 'node:http';
import type { Socket } from 'node:net';
import { type Timings } from '@szmarczak/http-timer';
import Options from './options.js';
import { type PlainResponse, type Response } from './response.js';
import { RequestError } from './errors.js';
type Error = NodeJS.ErrnoException;
export type Progress = {
percent: number;
transferred: number;
total?: number;
};
export type GotEventFunction<T> =
/**
All available HTTP request methods provided by Got.
*/
export declare type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'HEAD' | 'DELETE' | 'OPTIONS' | 'TRACE' | 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'trace';
declare type Promisable<T> = T | Promise<T>;
export declare type InitHook = (options: Options) => void;
export declare type BeforeRequestHook = (options: NormalizedOptions) => Promisable<void | Response | ResponseLike>;
export declare type BeforeRedirectHook = (options: NormalizedOptions, response: Response) => Promisable<void>;
export declare type BeforeErrorHook = (error: RequestError) => Promisable<RequestError>;
export declare type BeforeRetryHook = (options: NormalizedOptions, error?: RequestError, retryCount?: number) => void | Promise<void>;
interface PlainHooks {
/**
Called with plain request options, right before their normalization.
This is especially useful in conjunction with `got.extend()` when the input needs custom handling.
`request` event to get the request object of the request.
__Note #1__: This hook must be synchronous!
__Tip__: You can use `request` event to abort requests.
__Note #2__: Errors in this hook will be converted into an instances of `RequestError`.
@example
```
import got from 'got';
__Note #3__: The options object may not have a `url` property.
To modify it, use a `beforeRequest` hook instead.
@default []
*/
init?: InitHook[];
/**
Called with normalized request options.
Got will make no further changes to the request before it is sent.
This is especially useful in conjunction with `got.extend()` when you want to create an API client that, for example, uses HMAC-signing.
@default []
*/
beforeRequest?: BeforeRequestHook[];
/**
Called with normalized request options and the redirect response.
Got will make no further changes to the request.
This is especially useful when you want to avoid dead sites.
@default []
@example
```
const got = require('got');
got('https://example.com', {
hooks: {
beforeRedirect: [
(options, response) => {
if (options.hostname === 'deadSite') {
options.hostname = 'fallbackSite';
}
}
]
}
});
```
*/
beforeRedirect?: BeforeRedirectHook[];
/**
Called with an `Error` instance.
The error is passed to the hook right before it's thrown.
This is especially useful when you want to have more detailed errors.
__Note__: Errors thrown while normalizing input options are thrown directly and not part of this hook.
@default []
@example
```
const got = require('got');
got('https://api.github.com/some-endpoint', {
hooks: {
beforeError: [
error => {
const {response} = error;
if (response && response.body) {
error.name = 'GitHubError';
error.message = `${response.body.message} (${response.statusCode})`;
}
return error;
}
]
}
});
```
*/
beforeError?: BeforeErrorHook[];
/**
Called with normalized request options, the error and the retry count.
Got will make no further changes to the request.
This is especially useful when some extra work is required before the next try.
__Note__: When using streams, this hook is ignored.
__Note__: When retrying in a `afterResponse` hook, all remaining `beforeRetry` hooks will be called without the `error` and `retryCount` arguments.
@default []
@example
```
const got = require('got');
got.post('https://example.com', {
hooks: {
beforeRetry: [
(options, error, retryCount) => {
if (error.response.statusCode === 413) { // Payload too large
options.body = getNewBody();
}
}
]
}
});
```
*/
beforeRetry?: BeforeRetryHook[];
}
got.stream('https://github.com')
.on('request', request => setTimeout(() => request.destroy(), 50));
```
*/
((name: 'request', listener: (request: ClientRequest) => void) => T)
/**
All available hook of Got.
The `response` event to get the response object of the final request.
*/
export interface Hooks extends PromiseOnly.Hooks, PlainHooks {
}
declare type PlainHookEvent = 'init' | 'beforeRequest' | 'beforeRedirect' | 'beforeError' | 'beforeRetry';
& (<R extends Response>(name: 'response', listener: (response: R) => void) => T)
/**
All hook events acceptable by Got.
The `redirect` event to get the response object of a redirect. The second argument is options for the next request to the redirect location.
*/
export declare type HookEvent = PromiseOnly.HookEvent | PlainHookEvent;
export declare const knownHookEvents: HookEvent[];
declare type AcceptableResponse = IncomingMessageWithTimings | ResponseLike;
declare type AcceptableRequestResult = AcceptableResponse | ClientRequest | Promise<AcceptableResponse | ClientRequest> | undefined;
export declare type RequestFunction = (url: URL, options: RequestOptions, callback?: (response: AcceptableResponse) => void) => AcceptableRequestResult;
export declare type Headers = Record<string, string | string[] | undefined>;
declare type CheckServerIdentityFunction = (hostname: string, certificate: DetailedPeerCertificate) => Error | void;
export declare type ParseJsonFunction = (text: string) => unknown;
export declare type StringifyJsonFunction = (object: unknown) => string;
export interface RetryObject {
attemptCount: number;
retryOptions: RequiredRetryOptions;
error: TimeoutError | RequestError;
computedValue: number;
retryAfter?: number;
}
export declare type RetryFunction = (retryObject: RetryObject) => number | Promise<number>;
& (<R extends Response, N extends Options>(name: 'redirect', listener: (response: R, nextOptions: N) => void) => T)
/**
An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
Progress events for uploading (sending a request) and downloading (receiving a response).
The `progress` argument is an object like:
Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
By default, it retries *only* on the specified methods, status codes, and on these network errors:
- `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
- `ECONNRESET`: Connection was forcibly closed by a peer.
- `EADDRINUSE`: Could not bind to any free port.
- `ECONNREFUSED`: Connection was refused by the server.
- `EPIPE`: The remote side of the stream being written has been closed.
- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
- `ENETUNREACH`: No internet connection.
- `EAI_AGAIN`: DNS lookup timed out.
__Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
__Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
*/
export interface RequiredRetryOptions {
limit: number;
methods: Method[];
statusCodes: number[];
errorCodes: string[];
calculateDelay: RetryFunction;
maxRetryAfter?: number;
```
{
percent: 0.1,
transferred: 1024,
total: 10240
}
export interface CacheOptions {
shared?: boolean;
cacheHeuristic?: number;
immutableMinTimeToLive?: number;
ignoreCargoCult?: boolean;
}
interface PlainOptions extends URLOptions {
/**
Custom request function.
The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
```
@default http.request | https.request
*/
request?: RequestFunction;
/**
An object representing `http`, `https` and `http2` keys for [`http.Agent`](https://nodejs.org/api/http.html#http_class_http_agent), [`https.Agent`](https://nodejs.org/api/https.html#https_class_https_agent) and [`http2wrapper.Agent`](https://github.com/szmarczak/http2-wrapper#new-http2agentoptions) instance.
This is necessary because a request to one protocol might redirect to another.
In such a scenario, Got will switch over to the right protocol agent for you.
If the `content-length` header is missing, `total` will be `undefined`.
If a key is not present, it will default to a global agent.
@example
```
import got from 'got';
@example
```
const got = require('got');
const HttpAgent = require('agentkeepalive');
const {HttpsAgent} = HttpAgent;
got('https://sindresorhus.com', {
agent: {
http: new HttpAgent(),
https: new HttpsAgent()
}
const response = await got('https://sindresorhus.com')
.on('downloadProgress', progress => {
// Report download progress
})
.on('uploadProgress', progress => {
// Report upload progress
});
```
*/
agent?: Agents | false;
/**
Decompress the response automatically.
This will set the `accept-encoding` header to `gzip, deflate, br` on Node.js 11.7.0+ or `gzip, deflate` for older Node.js versions, unless you set it yourself.
Brotli (`br`) support requires Node.js 11.7.0 or later.
console.log(response);
```
*/
& ((name: 'uploadProgress' | 'downloadProgress', listener: (progress: Progress) => void) => T)
/**
To enable retrying on a Got stream, it is required to have a `retry` handler attached.
If this is disabled, a compressed response is returned as a `Buffer`.
This may be useful if you want to handle decompression yourself or stream the raw compressed data.
When this event is emitted, you should reset the stream you were writing to and prepare the body again.
@default true
*/
decompress?: boolean;
/**
Milliseconds to wait for the server to end the response before aborting the request with `got.TimeoutError` error (a.k.a. `request` property).
By default, there's no timeout.
This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle:
- `lookup` starts when a socket is assigned and ends when the hostname has been resolved.
Does not apply when using a Unix domain socket.
- `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected.
- `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only).
- `socket` starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback).
- `response` starts when the request has been written to the socket and ends when the response headers are received.
- `send` starts when the socket is connected and ends with the request has been written to the socket.
- `request` starts when the request is initiated and ends when the response's end event fires.
*/
timeout?: Delays | number;
/**
When specified, `prefixUrl` will be prepended to `url`.
The prefix can be any valid URL, either relative or absolute.
A trailing slash `/` is optional - one will be added automatically.
__Note__: `prefixUrl` will be ignored if the `url` argument is a URL instance.
__Note__: Leading slashes in `input` are disallowed when using this option to enforce consistency and avoid confusion.
For example, when the prefix URL is `https://example.com/foo` and the input is `/bar`, there's ambiguity whether the resulting URL would become `https://example.com/foo/bar` or `https://example.com/bar`.
The latter is used by browsers.
__Tip__: Useful when used with `got.extend()` to create niche-specific Got instances.
__Tip__: You can change `prefixUrl` using hooks as long as the URL still includes the `prefixUrl`.
If the URL doesn't include it anymore, it will throw.
@example
```
const got = require('got');
(async () => {
await got('unicorn', {prefixUrl: 'https://cats.com'});
//=> 'https://cats.com/unicorn'
const instance = got.extend({
prefixUrl: 'https://google.com'
});
await instance('unicorn', {
hooks: {
beforeRequest: [
options => {
options.prefixUrl = 'https://cats.com';
}
]
}
});
//=> 'https://cats.com/unicorn'
})();
```
*/
prefixUrl?: string | URL;
/**
__Note #1__: The `body` option cannot be used with the `json` or `form` option.
__Note #2__: If you provide this option, `got.stream()` will be read-only.
__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`.
*/
body?: string | Buffer | Readable;
/**
The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
If the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
__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.
*/
form?: Record<string, any>;
/**
JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
__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?: Record<string, any>;
/**
The URL to request, as a string, a [`https.request` options object](https://nodejs.org/api/https.html#https_https_request_options_callback), or a [WHATWG `URL`](https://nodejs.org/api/url.html#url_class_url).
Properties from `options` will override properties in the parsed `url`.
If no protocol is specified, it will throw a `TypeError`.
__Note__: The query string is **not** parsed as search params.
@example
```
got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
// The query string is overridden by `searchParams`
got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
```
*/
url?: string | URL;
/**
Cookie support. You don't have to care about parsing or how to store them.
__Note__: If you provide this option, `options.headers.cookie` will be overridden.
*/
cookieJar?: PromiseCookieJar | ToughCookieJar;
/**
Ignore invalid cookies instead of throwing an error.
Only useful when the `cookieJar` option has been set. Not recommended.
@default false
*/
ignoreInvalidCookies?: boolean;
/**
Query string that will be added to the request URL.
This will override the query string in `url`.
If you need to pass in an array, you can do it using a `URLSearchParams` instance.
@example
```
const got = require('got');
const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
got('https://example.com', {searchParams});
console.log(searchParams.toString());
//=> 'key=a&key=b'
```
*/
searchParams?: string | Record<string, string | number | boolean | null | undefined> | URLSearchParams;
/**
An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
Useful when making lots of requests to different *public* hostnames.
`CacheableLookup` uses `dns.resolver4(..)` and `dns.resolver6(...)` under the hood and fall backs to `dns.lookup(...)` when the first two fail, which may lead to additional delay.
__Note__: This should stay disabled when making requests to internal hostnames such as `localhost`, `database.local` etc.
@default false
*/
dnsCache?: CacheableLookup | boolean;
/**
User data. In contrast to other options, `context` is not enumerable.
__Note__: The object is never merged, it's just passed through.
Got will not modify the object in any way.
@example
```
const got = require('got');
const instance = got.extend({
hooks: {
beforeRequest: [
options => {
if (!options.context || !options.context.token) {
throw new Error('Token required');
}
options.headers.token = options.context.token;
}
]
}
});
(async () => {
const context = {
token: 'secret'
};
const response = await instance('https://httpbin.org/headers', {context});
// Let's see the headers
console.log(response.body);
})();
```
*/
context?: Record<string, unknown>;
/**
Hooks allow modifications during the request lifecycle.
Hook functions may be async and are run serially.
*/
hooks?: Hooks;
/**
Defines if redirect responses should be followed automatically.
Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`.
This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4).
@default true
*/
followRedirect?: boolean;
/**
If exceeded, the request will be aborted and a `MaxRedirectsError` will be thrown.
@default 10
*/
maxRedirects?: number;
/**
A cache adapter instance for storing cached response data.
@default false
*/
cache?: string | CacheableRequest.StorageAdapter | false;
/**
Determines if a `got.HTTPError` is thrown for unsuccessful responses.
If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing.
This may be useful if you are checking for resource availability and are expecting error responses.
@default true
*/
throwHttpErrors?: boolean;
username?: string;
password?: string;
/**
If set to `true`, Got will additionally accept HTTP2 requests.
It will choose either HTTP/1.1 or HTTP/2 depending on the ALPN protocol.
__Note__: Overriding `options.request` will disable HTTP2 support.
__Note__: This option will default to `true` in the next upcoming major release.
@default false
@example
```
const got = require('got');
(async () => {
const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
console.log(headers.via);
//=> '2 nghttpx'
})();
```
*/
http2?: boolean;
/**
Set this to `true` to allow sending body for the `GET` method.
However, the [HTTP/2 specification](https://tools.ietf.org/html/rfc7540#section-8.1.3) says that `An HTTP GET request includes request header fields and no payload body`, therefore when using the HTTP/2 protocol this option will have no effect.
This option is only meant to interact with non-compliant servers when you have no other choice.
__Note__: The [RFC 7321](https://tools.ietf.org/html/rfc7231#section-4.3.1) doesn't specify any particular behavior for the GET method having a payload, therefore __it's considered an [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern)__.
@default false
*/
allowGetBody?: boolean;
lookup?: CacheableLookup['lookup'];
/**
Request headers.
Existing headers will be overwritten. Headers set to `undefined` will be omitted.
@default {}
*/
headers?: Headers;
/**
By default, redirects will use [method rewriting](https://tools.ietf.org/html/rfc7231#section-6.4).
For example, when sending a POST request and receiving a `302`, it will resend the body to the new location using the same HTTP method (`POST` in this case).
@default true
*/
methodRewriting?: boolean;
/**
Indicates which DNS record family to use.
Values:
- `auto`: IPv4 (if present) or IPv6
- `ipv4`: Only IPv4
- `ipv6`: Only IPv6
__Note__: If you are using the undocumented option `family`, `dnsLookupIpVersion` will override it.
@default 'auto'
*/
dnsLookupIpVersion?: DnsLookupIpVersion;
/**
A function used to parse JSON responses.
@example
```
const got = require('got');
const Bourne = require('@hapi/bourne');
(async () => {
const parsed = await got('https://example.com', {
parseJson: text => Bourne.parse(text)
}).json();
console.log(parsed);
})();
```
*/
parseJson?: ParseJsonFunction;
/**
A function used to stringify the body of JSON requests.
@example
```
const got = require('got');
(async () => {
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (key.startsWith('_')) {
return;
}
return value;
}),
json: {
some: 'payload',
_ignoreMe: 1234
}
});
})();
```
@example
```
const got = require('got');
(async () => {
await got.post('https://example.com', {
stringifyJson: object => JSON.stringify(object, (key, value) => {
if (typeof value === 'number') {
return value.toString();
}
return value;
}),
json: {
some: 'payload',
number: 1
}
});
})();
```
*/
stringifyJson?: StringifyJsonFunction;
/**
An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
By default, it retries *only* on the specified methods, status codes, and on these network errors:
- `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
- `ECONNRESET`: Connection was forcibly closed by a peer.
- `EADDRINUSE`: Could not bind to any free port.
- `ECONNREFUSED`: Connection was refused by the server.
- `EPIPE`: The remote side of the stream being written has been closed.
- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
- `ENETUNREACH`: No internet connection.
- `EAI_AGAIN`: DNS lookup timed out.
__Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
__Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
*/
retry?: Partial<RequiredRetryOptions> | number;
/**
The IP address used to send the request from.
*/
localAddress?: string;
socketPath?: string;
/**
The HTTP method used to make the request.
@default 'GET'
*/
method?: Method;
createConnection?: (options: http.RequestOptions, oncreate: (error: Error, socket: Socket) => void) => Socket;
cacheOptions?: CacheOptions;
/**
If set to `false`, all invalid SSL certificates will be ignored and no error will be thrown.
If set to `true`, it will throw an error whenever an invalid SSL certificate is detected.
We strongly recommend to have this set to `true` for security reasons.
@default true
@example
```
const got = require('got');
(async () => {
// Correct:
await got('https://example.com', {rejectUnauthorized: true});
// You can disable it when developing an HTTPS app:
await got('https://localhost', {rejectUnauthorized: false});
// Never do this:
await got('https://example.com', {rejectUnauthorized: false});
})();
```
*/
rejectUnauthorized?: boolean;
/**
Options for the advanced HTTPS API.
*/
https?: HTTPSOptions;
}
export interface Options extends PromiseOnly.Options, PlainOptions {
}
export interface HTTPSOptions {
rejectUnauthorized?: https.RequestOptions['rejectUnauthorized'];
checkServerIdentity?: CheckServerIdentityFunction;
/**
Override the default Certificate Authorities ([from Mozilla](https://ccadb-public.secure.force.com/mozilla/IncludedCACertificateReport)).
@example
```
// Single Certificate Authority
got('https://example.com', {
https: {
certificateAuthority: fs.readFileSync('./my_ca.pem')
}
});
```
*/
certificateAuthority?: SecureContextOptions['ca'];
/**
Private keys in [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) format.
[PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) allows the option of private keys being encrypted.
Encrypted keys will be decrypted with `options.https.passphrase`.
Multiple keys with different passphrases can be provided as an array of `{pem: <string | Buffer>, passphrase: <string>}`
*/
key?: SecureContextOptions['key'];
/**
[Certificate chains](https://en.wikipedia.org/wiki/X.509#Certificate_chains_and_cross-certification) in [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) format.
One cert chain should be provided per private key (`options.https.key`).
When providing multiple cert chains, they do not have to be in the same order as their private keys in `options.https.key`.
If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail.
*/
certificate?: SecureContextOptions['cert'];
/**
The passphrase to decrypt the `options.https.key` (if different keys have different passphrases refer to `options.https.key` documentation).
*/
passphrase?: SecureContextOptions['passphrase'];
pfx?: SecureContextOptions['pfx'];
}
interface NormalizedPlainOptions extends PlainOptions {
method: Method;
url: URL;
timeout: Delays;
prefixUrl: string;
ignoreInvalidCookies: boolean;
decompress: boolean;
searchParams?: URLSearchParams;
cookieJar?: PromiseCookieJar;
headers: Headers;
context: Record<string, unknown>;
hooks: Required<Hooks>;
followRedirect: boolean;
maxRedirects: number;
cache?: string | CacheableRequest.StorageAdapter;
throwHttpErrors: boolean;
dnsCache?: CacheableLookup;
http2: boolean;
allowGetBody: boolean;
rejectUnauthorized: boolean;
lookup?: CacheableLookup['lookup'];
methodRewriting: boolean;
username: string;
password: string;
parseJson: ParseJsonFunction;
stringifyJson: StringifyJsonFunction;
retry: RequiredRetryOptions;
cacheOptions: CacheOptions;
[kRequest]: HttpRequestFunction;
[kIsNormalizedAlready]?: boolean;
}
export interface NormalizedOptions extends PromiseOnly.NormalizedOptions, NormalizedPlainOptions {
}
interface PlainDefaults {
timeout: Delays;
prefixUrl: string;
method: Method;
ignoreInvalidCookies: boolean;
decompress: boolean;
context: Record<string, unknown>;
cookieJar?: PromiseCookieJar | ToughCookieJar;
dnsCache?: CacheableLookup;
headers: Headers;
hooks: Required<Hooks>;
followRedirect: boolean;
maxRedirects: number;
cache?: string | CacheableRequest.StorageAdapter;
throwHttpErrors: boolean;
http2: boolean;
allowGetBody: boolean;
https?: HTTPSOptions;
methodRewriting: boolean;
parseJson: ParseJsonFunction;
stringifyJson: StringifyJsonFunction;
retry: RequiredRetryOptions;
agent?: Agents | false;
request?: RequestFunction;
searchParams?: URLSearchParams;
lookup?: CacheableLookup['lookup'];
localAddress?: string;
createConnection?: Options['createConnection'];
cacheOptions: CacheOptions;
}
export interface Defaults extends PromiseOnly.Defaults, PlainDefaults {
}
export interface Progress {
percent: number;
transferred: number;
total?: number;
}
export interface PlainResponse extends IncomingMessageWithTimings {
/**
The original request URL.
*/
requestUrl: string;
/**
The redirect URLs.
*/
redirectUrls: string[];
/**
- `options` - The Got options that were set on this request.
__Note__: This is not a [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest).
*/
request: Request;
/**
The remote IP address.
This is hopefully a temporary limitation, see [lukechilds/cacheable-request#86](https://github.com/lukechilds/cacheable-request/issues/86).
__Note__: Not available when the response is cached.
*/
ip?: string;
/**
Whether the response was retrieved from the cache.
*/
isFromCache: boolean;
/**
The status code of the response.
*/
statusCode: number;
/**
The request URL or the final URL after redirects.
*/
url: string;
/**
The object contains the following properties:
- `start` - Time when the request started.
- `socket` - Time when a socket was assigned to the request.
- `lookup` - Time when the DNS lookup finished.
- `connect` - Time when the socket successfully connected.
- `secureConnect` - Time when the socket securely connected.
- `upload` - Time when the request finished uploading.
- `response` - Time when the request fired `response` event.
- `end` - Time when the response fired `end` event.
- `error` - Time when the request fired `error` event.
- `abort` - Time when the request fired `abort` event.
- `phases`
- `wait` - `timings.socket - timings.start`
- `dns` - `timings.lookup - timings.socket`
- `tcp` - `timings.connect - timings.lookup`
- `tls` - `timings.secureConnect - timings.connect`
- `request` - `timings.upload - (timings.secureConnect || timings.connect)`
- `firstByte` - `timings.response - timings.upload`
- `download` - `timings.end - timings.response`
- `total` - `(timings.end || timings.error || timings.abort) - timings.start`
If something has not been measured yet, it will be `undefined`.
__Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
*/
timings: Timings;
/**
The number of times the request was retried.
*/
retryCount: number;
/**
The raw result of the request.
*/
rawBody?: Buffer;
/**
The result of the request.
*/
body?: unknown;
}
export interface Response<T = unknown> extends PlainResponse {
/**
The result of the request.
*/
body: T;
/**
The raw result of the request.
*/
rawBody: Buffer;
}
export interface RequestEvents<T> {
/**
`request` event to get the request object of the request.
__Tip__: You can use `request` event to abort requests.
@example
```
got.stream('https://github.com')
.on('request', request => setTimeout(() => request.destroy(), 50));
```
*/
on: ((name: 'request', listener: (request: http.ClientRequest) => void) => T)
/**
The `response` event to get the response object of the final request.
*/
& (<R extends Response>(name: 'response', listener: (response: R) => void) => T)
/**
The `redirect` event to get the response object of a redirect. The second argument is options for the next request to the redirect location.
*/
& (<R extends Response, N extends NormalizedOptions>(name: 'redirect', listener: (response: R, nextOptions: N) => void) => T)
/**
Progress events for uploading (sending a request) and downloading (receiving a response).
The `progress` argument is an object like:
```js
{
percent: 0.1,
transferred: 1024,
total: 10240
}
```
If the `content-length` header is missing, `total` will be `undefined`.
@example
```js
(async () => {
const response = await got('https://sindresorhus.com')
.on('downloadProgress', progress => {
// Report download progress
})
.on('uploadProgress', progress => {
// Report upload progress
});
console.log(response);
})();
```
*/
& ((name: 'uploadProgress' | 'downloadProgress', listener: (progress: Progress) => void) => T)
/**
To enable retrying on a Got stream, it is required to have a `retry` handler attached.
When this event is emitted, you should reset the stream you were writing to and prepare the body again.
See `got.options.retry` for more information.
*/
& ((name: 'retry', listener: (retryCount: number, error: RequestError) => void) => T);
}
export declare const setNonEnumerableProperties: (sources: Array<Options | Defaults | undefined>, to: Options) => void;
/**
An error to be thrown when a request fails.
Contains a `code` property with error class code, like `ECONNREFUSED`.
See `got.options.retry` for more information.
*/
export declare class RequestError extends Error {
code: string;
stack: string;
readonly options: NormalizedOptions;
readonly response?: Response;
readonly request?: Request;
readonly timings?: Timings;
constructor(message: string, error: Partial<Error & {
code?: string;
}>, self: Request | NormalizedOptions);
}
/**
An error to be thrown when the server redirects you more than ten times.
Includes a `response` property.
*/
export declare class MaxRedirectsError extends RequestError {
readonly response: Response;
readonly request: Request;
readonly timings: Timings;
constructor(request: Request);
}
/**
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 extends RequestError {
readonly response: Response;
readonly request: Request;
readonly timings: Timings;
constructor(response: Response);
}
/**
An error to be thrown when a cache method fails.
For example, if the database goes down or there's a filesystem error.
*/
export declare class CacheError extends RequestError {
readonly request: Request;
constructor(error: Error, request: Request);
}
/**
An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
*/
export declare class UploadError extends RequestError {
readonly request: Request;
constructor(error: Error, request: Request);
}
/**
An error to be thrown when the request is aborted due to a timeout.
Includes an `event` and `timings` property.
*/
export declare class TimeoutError extends RequestError {
readonly request: Request;
readonly timings: Timings;
readonly event: string;
constructor(error: TimedOutTimeoutError, timings: Timings, request: Request);
}
/**
An error to be thrown when reading from response stream fails.
*/
export declare class ReadError extends RequestError {
readonly request: Request;
readonly response: Response;
readonly timings: Timings;
constructor(error: Error, request: Request);
}
/**
An error to be thrown when given an unsupported protocol.
*/
export declare class UnsupportedProtocolError extends RequestError {
constructor(options: NormalizedOptions);
}
& ((name: 'retry', listener: (retryCount: number, error: RequestError) => void) => T);
export type RequestEvents<T> = {
on: GotEventFunction<T>;
once: GotEventFunction<T>;
off: GotEventFunction<T>;
};
type UrlType = ConstructorParameters<typeof Options>[0];
type OptionsType = ConstructorParameters<typeof Options>[1];
type DefaultsType = ConstructorParameters<typeof Options>[2];
export default class Request extends Duplex implements RequestEvents<Request> {
['constructor']: typeof Request;
[kUnproxyEvents]: () => void;
_cannotHaveBody: boolean;
[kDownloadedSize]: number;
[kUploadedSize]: number;
[kStopReading]: boolean;
[kTriggerRead]: boolean;
[kBody]: Options['body'];
[kJobs]: Array<() => void>;
[kRetryTimeout]?: NodeJS.Timeout;
[kBodySize]?: number;
[kServerResponsesPiped]: Set<ServerResponse>;
[kIsFromCache]?: boolean;
[kStartedReading]?: boolean;
[kCancelTimeouts]?: () => void;
[kResponseSize]?: number;
[kResponse]?: IncomingMessageWithTimings;
[kOriginalResponse]?: IncomingMessageWithTimings;
[kRequest]?: ClientRequest;
_noPipe?: boolean;
_progressCallbacks: Array<() => void>;
options: NormalizedOptions;
requestUrl: string;
requestInitialized: boolean;
redirects: string[];
options: Options;
response?: PlainResponse;
requestUrl?: URL;
redirectUrls: URL[];
retryCount: number;
constructor(url: string | URL | undefined, options?: Options, defaults?: Defaults);
static normalizeArguments(url?: string | URL, options?: Options, defaults?: Defaults): NormalizedOptions;
_lockWrite(): void;
_unlockWrite(): void;
_finalizeBody(): Promise<void>;
_onResponseBase(response: IncomingMessageWithTimings): Promise<void>;
_onResponse(response: IncomingMessageWithTimings): Promise<void>;
_onRequest(request: ClientRequest): void;
_createCacheableRequest(url: URL, options: RequestOptions): Promise<ClientRequest | ResponseLike>;
_makeRequest(): Promise<void>;
_error(error: RequestError): Promise<void>;
private _requestOptions;
private _stopRetry;
private _downloadedSize;
private _uploadedSize;
private _stopReading;
private readonly _pipedServerResponses;
private _request?;
private _responseSize?;
private _bodySize?;
private _unproxyEvents;
private _isFromCache?;
private _cannotHaveBody;
private _triggerRead;
private readonly _jobs;
private _cancelTimeouts;
private readonly _removeListeners;
private _nativeResponse?;
private _flushed;
private _aborted;
private _requestInitialized;
constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType);
flush(): Promise<void>;
_beforeError(error: Error): void;
_read(): void;
_write(chunk: any, encoding: string | undefined, callback: (error?: Error | null) => void): void;
_writeRequest(chunk: any, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void;
_write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void;
_final(callback: (error?: Error | null) => void): void;
_destroy(error: Error | null, callback: (error: Error | null) => void): void;
get _isAboutToError(): boolean;
pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
end?: boolean;
}): T;
unpipe<T extends NodeJS.WritableStream>(destination: T): this;
private _finalizeBody;
private _onResponseBase;
private _setRawBody;
private _onResponse;
private _onRequest;
private _asyncWrite;
private _sendBody;
private _prepareCache;
private _createCacheableRequest;
private _makeRequest;
private _error;
private _writeRequest;
/**

@@ -1077,3 +147,3 @@ The remote IP address.

*/
get aborted(): boolean;
get isAborted(): boolean;
get socket(): Socket | undefined;

@@ -1120,7 +190,4 @@ /**

get isFromCache(): boolean | undefined;
pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
end?: boolean;
}): T;
unpipe<T extends NodeJS.WritableStream>(destination: T): this;
get reusedSocket(): boolean | undefined;
}
export {};

6

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

@@ -1,3 +0,3 @@

import { ClientRequestArgs } from 'http';
declare const _default: (body: unknown, headers: ClientRequestArgs['headers']) => Promise<number | undefined>;
export default _default;
/// <reference types="node" resolution-mode="require"/>
import type { ClientRequestArgs } from 'node:http';
export default function getBodySize(body: unknown, headers: ClientRequestArgs['headers']): Promise<number | undefined>;

30

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

@@ -1,9 +0,6 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs_1 = require("fs");
const util_1 = require("util");
const is_1 = require("@sindresorhus/is");
const is_form_data_1 = require("./is-form-data");
const statAsync = util_1.promisify(fs_1.stat);
exports.default = async (body, headers) => {
import { Buffer } from 'node:buffer';
import { promisify } from 'node:util';
import is from '@sindresorhus/is';
import isFormData from './is-form-data.js';
export default async function getBodySize(body, headers) {
if (headers && 'content-length' in headers) {

@@ -15,19 +12,12 @@ return Number(headers['content-length']);

}
if (is_1.default.string(body)) {
if (is.string(body)) {
return Buffer.byteLength(body);
}
if (is_1.default.buffer(body)) {
if (is.buffer(body)) {
return body.length;
}
if (is_form_data_1.default(body)) {
return util_1.promisify(body.getLength.bind(body))();
if (isFormData(body)) {
return promisify(body.getLength.bind(body))();
}
if (body instanceof fs_1.ReadStream) {
const { size } = await statAsync(body.path);
if (size === 0) {
return undefined;
}
return size;
}
return undefined;
};
}

12

dist/source/core/utils/is-form-data.d.ts

@@ -1,8 +0,8 @@

/// <reference types="node" />
import { Readable } from 'stream';
interface FormData extends Readable {
/// <reference types="node" resolution-mode="require"/>
import type { Readable } from 'node:stream';
type FormData = {
getBoundary: () => string;
getLength: (callback: (error: Error | null, length: number) => void) => void;
}
declare const _default: (body: unknown) => body is FormData;
export default _default;
} & Readable;
export default function isFormData(body: unknown): body is FormData;
export {};

8

dist/source/core/utils/is-form-data.js

@@ -1,4 +0,4 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const is_1 = require("@sindresorhus/is");
exports.default = (body) => is_1.default.nodeStream(body) && is_1.default.function_(body.getBoundary);
import is from '@sindresorhus/is';
export default function isFormData(body) {
return is.nodeStream(body) && is.function_(body.getBoundary);
}

9

dist/source/core/utils/options-to-url.d.ts

@@ -1,3 +0,3 @@

import { URL } from 'url';
export interface URLOptions {
/// <reference types="node" resolution-mode="require"/>
export type URLOptions = {
href?: string;

@@ -12,4 +12,3 @@ protocol?: string;

path?: string;
}
declare const _default: (origin: string, options: URLOptions) => URL;
export default _default;
};
export default function optionsToUrl(origin: string, options: URLOptions): URL;

15

dist/source/core/utils/options-to-url.js

@@ -1,5 +0,1 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/* istanbul ignore file: deprecated */
const url_1 = require("url");
const keys = [

@@ -11,6 +7,5 @@ 'protocol',

'pathname',
'search'
'search',
];
exports.default = (origin, options) => {
var _a, _b;
export default function optionsToUrl(origin, options) {
if (options.path) {

@@ -34,5 +29,5 @@ if (options.pathname) {

}
origin = `${options.protocol}//${(_b = (_a = options.hostname) !== null && _a !== void 0 ? _a : options.host) !== null && _b !== void 0 ? _b : ''}`;
origin = `${options.protocol}//${options.hostname ?? options.host ?? ''}`;
}
const url = new url_1.URL(origin);
const url = new URL(origin);
if (options.path) {

@@ -55,2 +50,2 @@ const searchIndex = options.path.indexOf('?');

return url;
};
}

6

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

@@ -1,3 +0,3 @@

/// <reference types="node" />
import { EventEmitter } from 'events';
export default function (from: EventEmitter, to: EventEmitter, events: string[]): () => void;
/// <reference types="node" resolution-mode="require"/>
import type { EventEmitter } from 'node:events';
export default function proxyEvents(from: EventEmitter, to: EventEmitter, events: Readonly<string[]>): () => void;

16

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

@@ -1,17 +0,15 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function default_1(from, to, events) {
const fns = {};
export default function proxyEvents(from, to, events) {
const eventFunctions = {};
for (const event of events) {
fns[event] = (...args) => {
const eventFunction = (...args) => {
to.emit(event, ...args);
};
from.on(event, fns[event]);
eventFunctions[event] = eventFunction;
from.on(event, eventFunction);
}
return () => {
for (const event of events) {
from.off(event, fns[event]);
for (const [event, eventFunction] of Object.entries(eventFunctions)) {
from.off(event, eventFunction);
}
};
}
exports.default = default_1;

18

dist/source/core/utils/unhandle.d.ts

@@ -1,11 +0,11 @@

/// <reference types="node" />
import { EventEmitter } from 'events';
declare type Origin = EventEmitter;
declare type Event = string | symbol;
declare type Fn = (...args: any[]) => void;
interface Unhandler {
/// <reference types="node" resolution-mode="require"/>
import type { EventEmitter } from 'node:events';
type Origin = EventEmitter;
type Event = string | symbol;
type Fn = (...args: any[]) => void;
type Unhandler = {
once: (origin: Origin, event: Event, fn: Fn) => void;
unhandleAll: () => void;
}
declare const _default: () => Unhandler;
export default _default;
};
export default function unhandle(): Unhandler;
export {};

8

dist/source/core/utils/unhandle.js

@@ -1,3 +0,1 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
// When attaching listeners, it's very easy to forget about them.

@@ -7,3 +5,3 @@ // Especially if you do error handling and set timeouts.

// use this simple tool which will remove all listeners you have attached.
exports.default = () => {
export default function unhandle() {
const handlers = [];

@@ -21,4 +19,4 @@ return {

handlers.length = 0;
}
},
};
};
}

10

dist/source/core/utils/url-to-options.d.ts

@@ -1,3 +0,4 @@

import { URL, UrlWithStringQuery } from 'url';
export interface LegacyUrlOptions {
/// <reference types="node" resolution-mode="require"/>
import type { UrlWithStringQuery } from 'node:url';
export type LegacyUrlOptions = {
protocol: string;

@@ -13,4 +14,3 @@ hostname: string;

auth?: string;
}
declare const _default: (url: URL | UrlWithStringQuery) => LegacyUrlOptions;
export default _default;
};
export default function urlToOptions(url: URL | UrlWithStringQuery): LegacyUrlOptions;

14

dist/source/core/utils/url-to-options.js

@@ -1,5 +0,3 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const is_1 = require("@sindresorhus/is");
exports.default = (url) => {
import is from '@sindresorhus/is';
export default function urlToOptions(url) {
// Cast to URL

@@ -9,3 +7,3 @@ url = url;

protocol: url.protocol,
hostname: is_1.default.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
hostname: is.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
host: url.host,

@@ -16,5 +14,5 @@ hash: url.hash,

href: url.href,
path: `${url.pathname || ''}${url.search || ''}`
path: `${url.pathname || ''}${url.search || ''}`,
};
if (is_1.default.string(url.port) && url.port.length > 0) {
if (is.string(url.port) && url.port.length > 0) {
options.port = Number(url.port);

@@ -26,2 +24,2 @@ }

return options;
};
}

7

dist/source/core/utils/weakable-map.js

@@ -1,4 +0,4 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class WeakableMap {
export default class WeakableMap {
weakMap;
map;
constructor() {

@@ -29,2 +29,1 @@ this.weakMap = new WeakMap();

}
exports.default = WeakableMap;

4

dist/source/create.d.ts

@@ -1,5 +0,3 @@

import { Got, HandlerFunction, InstanceDefaults } from './types';
export declare const defaultHandler: HandlerFunction;
import type { Got, InstanceDefaults } from './types.js';
declare const create: (defaults: InstanceDefaults) => Got;
export default create;
export * from './types';

265

dist/source/create.js

@@ -1,31 +0,5 @@

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.defaultHandler = void 0;
const is_1 = require("@sindresorhus/is");
const as_promise_1 = require("./as-promise");
const create_rejection_1 = require("./as-promise/create-rejection");
const core_1 = require("./core");
const deep_freeze_1 = require("./utils/deep-freeze");
const errors = {
RequestError: as_promise_1.RequestError,
CacheError: as_promise_1.CacheError,
ReadError: as_promise_1.ReadError,
HTTPError: as_promise_1.HTTPError,
MaxRedirectsError: as_promise_1.MaxRedirectsError,
TimeoutError: as_promise_1.TimeoutError,
ParseError: as_promise_1.ParseError,
CancelError: as_promise_1.CancelError,
UnsupportedProtocolError: as_promise_1.UnsupportedProtocolError,
UploadError: as_promise_1.UploadError
};
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';
// The `delay` package weighs 10KB (!)

@@ -35,12 +9,3 @@ const delay = async (ms) => new Promise(resolve => {

});
const { normalizeArguments } = core_1.default;
const mergeOptions = (...sources) => {
let mergedOptions;
for (const source of sources) {
mergedOptions = normalizeArguments(undefined, source, mergedOptions);
}
return mergedOptions;
};
const getPromiseOrStream = (options) => options.isStream ? new core_1.default(undefined, options) : as_promise_1.default(options);
const isGotInstance = (value) => ('defaults' in value && 'options' in value.defaults);
const isGotInstance = (value) => is.function_(value);
const aliases = [

@@ -52,105 +17,79 @@ 'get',

'head',
'delete'
'delete',
];
exports.defaultHandler = (options, next) => next(options);
const callInitHooks = (hooks, options) => {
if (hooks) {
for (const hook of hooks) {
hook(options);
}
}
};
const create = (defaults) => {
// Proxy properties from next handlers
defaults._rawHandlers = defaults.handlers;
defaults.handlers = defaults.handlers.map(fn => ((options, next) => {
// This will be assigned by assigning result
let root;
const result = fn(options, newOptions => {
root = next(newOptions);
return root;
});
if (result !== root && !options.isStream && root) {
const typedResult = result;
const { then: promiseThen, catch: promiseCatch, finally: promiseFianlly } = typedResult;
Object.setPrototypeOf(typedResult, Object.getPrototypeOf(root));
Object.defineProperties(typedResult, Object.getOwnPropertyDescriptors(root));
// These should point to the new promise
// eslint-disable-next-line promise/prefer-await-to-then
typedResult.then = promiseThen;
typedResult.catch = promiseCatch;
typedResult.finally = promiseFianlly;
}
return result;
}));
defaults = {
options: new Options(undefined, undefined, defaults.options),
handlers: [...defaults.handlers],
mutableDefaults: defaults.mutableDefaults,
};
Object.defineProperty(defaults, 'mutableDefaults', {
enumerable: true,
configurable: false,
writable: false,
});
// Got interface
const got = ((url, options = {}, _defaults) => {
var _a, _b;
const got = ((url, options, defaultOptions = defaults.options) => {
const request = new Request(url, options, defaultOptions);
let promise;
const lastHandler = (normalized) => {
// Note: `options` is `undefined` when `new Options(...)` fails
request.options = normalized;
request._noPipe = !normalized.isStream;
void request.flush();
if (normalized.isStream) {
return request;
}
if (!promise) {
promise = asPromise(request);
}
return promise;
};
let iteration = 0;
const iterateHandlers = (newOptions) => {
return defaults.handlers[iteration++](newOptions, iteration === defaults.handlers.length ? getPromiseOrStream : iterateHandlers);
const handler = defaults.handlers[iteration++] ?? lastHandler;
const result = handler(newOptions, iterateHandlers);
if (is.promise(result) && !request.options.isStream) {
if (!promise) {
promise = asPromise(request);
}
if (result !== promise) {
const descriptors = Object.getOwnPropertyDescriptors(promise);
for (const key in descriptors) {
if (key in result) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete descriptors[key];
}
}
// eslint-disable-next-line @typescript-eslint/no-floating-promises
Object.defineProperties(result, descriptors);
result.cancel = promise.cancel;
}
}
return result;
};
// TODO: Remove this in Got 12.
if (is_1.default.plainObject(url)) {
const mergedOptions = {
...url,
...options
};
core_1.setNonEnumerableProperties([url, options], mergedOptions);
options = mergedOptions;
url = undefined;
}
try {
// Call `init` hooks
let initHookError;
try {
callInitHooks(defaults.options.hooks.init, options);
callInitHooks((_a = options.hooks) === null || _a === void 0 ? void 0 : _a.init, options);
}
catch (error) {
initHookError = error;
}
// Normalize options & call handlers
const normalizedOptions = normalizeArguments(url, options, _defaults !== null && _defaults !== void 0 ? _defaults : defaults.options);
normalizedOptions[core_1.kIsNormalizedAlready] = true;
if (initHookError) {
throw new as_promise_1.RequestError(initHookError.message, initHookError, normalizedOptions);
}
return iterateHandlers(normalizedOptions);
}
catch (error) {
if (options.isStream) {
throw error;
}
else {
return create_rejection_1.default(error, defaults.options.hooks.beforeError, (_b = options.hooks) === null || _b === void 0 ? void 0 : _b.beforeError);
}
}
return iterateHandlers(request.options);
});
got.extend = (...instancesOrOptions) => {
const optionsArray = [defaults.options];
let handlers = [...defaults._rawHandlers];
let isMutableDefaults;
const options = new Options(undefined, undefined, defaults.options);
const handlers = [...defaults.handlers];
let mutableDefaults;
for (const value of instancesOrOptions) {
if (isGotInstance(value)) {
optionsArray.push(value.defaults.options);
handlers.push(...value.defaults._rawHandlers);
isMutableDefaults = value.defaults.mutableDefaults;
options.merge(value.defaults.options);
handlers.push(...value.defaults.handlers);
mutableDefaults = value.defaults.mutableDefaults;
}
else {
optionsArray.push(value);
if ('handlers' in value) {
options.merge(value);
if (value.handlers) {
handlers.push(...value.handlers);
}
isMutableDefaults = value.mutableDefaults;
mutableDefaults = value.mutableDefaults;
}
}
handlers = handlers.filter(handler => handler !== exports.defaultHandler);
if (handlers.length === 0) {
handlers.push(exports.defaultHandler);
}
return create({
options: mergeOptions(...optionsArray),
options,
handlers,
mutableDefaults: Boolean(isMutableDefaults)
mutableDefaults: Boolean(mutableDefaults),
});

@@ -160,12 +99,13 @@ };

const paginateEach = (async function* (url, options) {
// TODO: Remove this `@ts-expect-error` when upgrading to TypeScript 4.
// Error: Argument of type 'Merge<Options, PaginationOptions<T, R>> | undefined' is not assignable to parameter of type 'Options | undefined'.
// @ts-expect-error
let normalizedOptions = normalizeArguments(url, options, defaults.options);
let normalizedOptions = new Options(url, options, defaults.options);
normalizedOptions.resolveBodyOnly = false;
const pagination = normalizedOptions.pagination;
if (!is_1.default.object(pagination)) {
throw new TypeError('`options.pagination` must be implemented');
}
const all = [];
const { pagination } = normalizedOptions;
assert.function_(pagination.transform);
assert.function_(pagination.shouldContinue);
assert.function_(pagination.filter);
assert.function_(pagination.paginate);
assert.number(pagination.countLimit);
assert.number(pagination.requestLimit);
assert.number(pagination.backoff);
const allItems = [];
let { countLimit } = pagination;

@@ -178,12 +118,11 @@ let numberOfRequests = 0;

}
// @ts-expect-error FIXME!
// TODO: Throw when result is not an instance of Response
// eslint-disable-next-line no-await-in-loop
const result = (await got(undefined, undefined, normalizedOptions));
const response = (await got(undefined, undefined, normalizedOptions));
// eslint-disable-next-line no-await-in-loop
const parsed = await pagination.transform(result);
const current = [];
const parsed = await pagination.transform(response);
const currentItems = [];
assert.array(parsed);
for (const item of parsed) {
if (pagination.filter(item, all, current)) {
if (!pagination.shouldContinue(item, all, current)) {
if (pagination.filter({ item, currentItems, allItems })) {
if (!pagination.shouldContinue({ item, currentItems, allItems })) {
return;

@@ -193,5 +132,5 @@ }

if (pagination.stackAllItems) {
all.push(item);
allItems.push(item);
}
current.push(item);
currentItems.push(item);
if (--countLimit <= 0) {

@@ -202,11 +141,20 @@ return;

}
const optionsToMerge = pagination.paginate(result, all, current);
const optionsToMerge = pagination.paginate({
response,
currentItems,
allItems,
});
if (optionsToMerge === false) {
return;
}
if (optionsToMerge === result.request.options) {
normalizedOptions = result.request.options;
if (optionsToMerge === response.request.options) {
normalizedOptions = response.request.options;
}
else if (optionsToMerge !== undefined) {
normalizedOptions = normalizeArguments(undefined, optionsToMerge, normalizedOptions);
else {
normalizedOptions.merge(optionsToMerge);
assert.any([is.urlInstance, is.undefined], optionsToMerge.url);
if (optionsToMerge.url !== undefined) {
normalizedOptions.prefixUrl = '';
normalizedOptions.url = optionsToMerge.url;
}
}

@@ -231,17 +179,16 @@ numberOfRequests++;

got[method] = ((url, options) => got(url, { ...options, method }));
got.stream[method] = ((url, options) => {
return got(url, { ...options, method, isStream: true });
});
got.stream[method] = ((url, options) => got(url, { ...options, method, isStream: true }));
}
Object.assign(got, errors);
if (!defaults.mutableDefaults) {
Object.freeze(defaults.handlers);
defaults.options.freeze();
}
Object.defineProperty(got, 'defaults', {
value: defaults.mutableDefaults ? defaults : deep_freeze_1.default(defaults),
writable: defaults.mutableDefaults,
configurable: defaults.mutableDefaults,
enumerable: true
value: defaults,
writable: false,
configurable: false,
enumerable: true,
});
got.mergeOptions = mergeOptions;
return got;
};
exports.default = create;
__exportStar(require("./types"), exports);
export default create;

17

dist/source/index.d.ts

@@ -1,4 +0,15 @@

declare const got: import("./types").Got;
declare const got: import("./types.js").Got;
export default got;
export * from './create';
export * from './as-promise';
export { got };
export { default as Options } from './core/options.js';
export * from './core/options.js';
export * from './core/response.js';
export type { default as Request } from './core/index.js';
export * from './core/index.js';
export * from './core/errors.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 { default as create } from './create.js';
export { default as parseLinkHeader } from './core/parse-link-header.js';

149

dist/source/index.js

@@ -1,132 +0,21 @@

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
const url_1 = require("url");
const create_1 = require("./create");
import create from './create.js';
import Options from './core/options.js';
const defaults = {
options: {
method: 'GET',
retry: {
limit: 2,
methods: [
'GET',
'PUT',
'HEAD',
'DELETE',
'OPTIONS',
'TRACE'
],
statusCodes: [
408,
413,
429,
500,
502,
503,
504,
521,
522,
524
],
errorCodes: [
'ETIMEDOUT',
'ECONNRESET',
'EADDRINUSE',
'ECONNREFUSED',
'EPIPE',
'ENOTFOUND',
'ENETUNREACH',
'EAI_AGAIN'
],
maxRetryAfter: undefined,
calculateDelay: ({ computedValue }) => computedValue
},
timeout: {},
headers: {
'user-agent': 'got (https://github.com/sindresorhus/got)'
},
hooks: {
init: [],
beforeRequest: [],
beforeRedirect: [],
beforeRetry: [],
beforeError: [],
afterResponse: []
},
cache: undefined,
dnsCache: undefined,
decompress: true,
throwHttpErrors: true,
followRedirect: true,
isStream: false,
responseType: 'text',
resolveBodyOnly: false,
maxRedirects: 10,
prefixUrl: '',
methodRewriting: true,
ignoreInvalidCookies: false,
context: {},
// TODO: Set this to `true` when Got 12 gets released
http2: false,
allowGetBody: false,
https: undefined,
pagination: {
transform: (response) => {
if (response.request.options.responseType === 'json') {
return response.body;
}
return JSON.parse(response.body);
},
paginate: response => {
if (!Reflect.has(response.headers, 'link')) {
return false;
}
const items = response.headers.link.split(',');
let next;
for (const item of items) {
const parsed = item.split(';');
if (parsed[1].includes('next')) {
next = parsed[0].trimStart().trim();
next = next.slice(1, -1);
break;
}
}
if (next) {
const options = {
url: new url_1.URL(next)
};
return options;
}
return false;
},
filter: () => true,
shouldContinue: () => true,
countLimit: Infinity,
backoff: 0,
requestLimit: 10000,
stackAllItems: true
},
parseJson: (text) => JSON.parse(text),
stringifyJson: (object) => JSON.stringify(object),
cacheOptions: {}
},
handlers: [create_1.defaultHandler],
mutableDefaults: false
options: new Options(),
handlers: [],
mutableDefaults: false,
};
const got = create_1.default(defaults);
exports.default = got;
// For CommonJS default export support
module.exports = got;
module.exports.default = got;
module.exports.__esModule = true; // Workaround for TS issue: https://github.com/sindresorhus/got/pull/1267
__exportStar(require("./create"), exports);
__exportStar(require("./as-promise"), exports);
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';
export * from './core/index.js';
export * from './core/errors.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';

236

dist/source/types.d.ts

@@ -1,16 +0,19 @@

/// <reference types="node" />
import { URL } from 'url';
import { CancelError } from 'p-cancelable';
import { CancelableRequest, Response, Options, NormalizedOptions, Defaults as DefaultOptions, PaginationOptions, ParseError, RequestError, CacheError, ReadError, HTTPError, MaxRedirectsError, TimeoutError, UnsupportedProtocolError, UploadError } 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;
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
import type { Buffer } from 'node:buffer';
import type { CancelableRequest } from './as-promise/types.js';
import type { Response } from './core/response.js';
import type Options from './core/options.js';
import { type PaginationOptions, type OptionsInit } from './core/options.js';
import type Request from './core/index.js';
type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
/**
Defaults for each Got instance.
*/
export interface InstanceDefaults {
export type InstanceDefaults = {
/**
An object containing the default options of Got.
An object containing the default options of Got.
*/
options: DefaultOptions;
options: Options;
/**

@@ -31,8 +34,7 @@ An array of functions. You execute them directly by calling `got()`.

mutableDefaults: boolean;
_rawHandlers?: HandlerFunction[];
}
};
/**
A Request object returned by calling Got, or any of the Got HTTP alias request functions.
*/
export declare type GotReturn = Request | CancelableRequest;
export type GotReturn = Request | CancelableRequest;
/**

@@ -42,7 +44,7 @@ A function to handle options and returns a Request object.

*/
export declare type HandlerFunction = <T extends GotReturn>(options: NormalizedOptions, next: (options: NormalizedOptions) => T) => T | Promise<T>;
export type HandlerFunction = <T extends GotReturn>(options: Options, next: (options: Options) => T) => T | Promise<T>;
/**
The options available for `got.extend()`.
*/
export interface ExtendOptions extends Options {
export type ExtendOptions = {
/**

@@ -63,4 +65,4 @@ An array of functions. You execute them directly by calling `got()`.

mutableDefaults?: boolean;
}
export declare type OptionsOfTextResponseBody = Merge<Options, {
} & OptionsInit;
export type OptionsOfTextResponseBody = Merge<OptionsInit, {
isStream?: false;

@@ -70,3 +72,3 @@ resolveBodyOnly?: false;

}>;
export declare type OptionsOfJSONResponseBody = Merge<Options, {
export type OptionsOfJSONResponseBody = Merge<OptionsInit, {
isStream?: false;

@@ -76,3 +78,3 @@ resolveBodyOnly?: false;

}>;
export declare type OptionsOfBufferResponseBody = Merge<Options, {
export type OptionsOfBufferResponseBody = Merge<OptionsInit, {
isStream?: false;

@@ -82,18 +84,20 @@ resolveBodyOnly?: false;

}>;
export declare type OptionsOfUnknownResponseBody = Merge<Options, {
export type OptionsOfUnknownResponseBody = Merge<OptionsInit, {
isStream?: false;
resolveBodyOnly?: false;
}>;
export declare type StrictOptions = Except<Options, 'isStream' | 'responseType' | 'resolveBodyOnly'>;
export declare type StreamOptions = Merge<Options, {
export type StrictOptions = Except<OptionsInit, 'isStream' | 'responseType' | 'resolveBodyOnly'>;
export type StreamOptions = Merge<OptionsInit, {
isStream?: true;
}>;
declare type ResponseBodyOnly = {
type ResponseBodyOnly = {
resolveBodyOnly: true;
};
export declare type OptionsWithPagination<T = unknown, R = unknown> = Merge<Options, PaginationOptions<T, R>>;
export type OptionsWithPagination<T = unknown, R = unknown> = Merge<OptionsInit, {
pagination?: PaginationOptions<T, R>;
}>;
/**
An instance of `got.paginate`.
*/
export interface GotPaginate {
export type GotPaginate = {
/**

@@ -114,15 +118,15 @@ Same as `GotPaginate.each`.

```
(async () => {
const countLimit = 10;
import got from 'got';
const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
pagination: {countLimit}
});
const countLimit = 10;
console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
pagination: {countLimit}
});
for await (const commitData of pagination) {
console.log(commitData.commit.message);
}
})();
console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
for await (const commitData of pagination) {
console.log(commitData.commit.message);
}
```

@@ -138,17 +142,17 @@ */

```
(async () => {
const countLimit = 10;
import got from 'got';
const results = await got.paginate.all('https://api.github.com/repos/sindresorhus/got/commits', {
pagination: {countLimit}
});
const countLimit = 10;
console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
console.log(results);
})();
const results = await got.paginate.all('https://api.github.com/repos/sindresorhus/got/commits', {
pagination: {countLimit}
});
console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
console.log(results);
```
*/
all: (<T, R = unknown>(url: string | URL, options?: OptionsWithPagination<T, R>) => Promise<T[]>) & (<T, R = unknown>(options?: OptionsWithPagination<T, R>) => Promise<T[]>);
}
export interface GotRequestFunction {
};
export type GotRequestFunction = {
(url: string | URL, options?: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;

@@ -168,31 +172,29 @@ <T>(url: string | URL, options?: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;

(options: (Merge<OptionsOfBufferResponseBody, ResponseBodyOnly>)): CancelableRequest<Buffer>;
(url: string | URL, options?: Merge<Options, {
(url: string | URL, options?: Merge<OptionsInit, {
isStream: true;
}>): Request;
(options: Merge<Options, {
(options: Merge<OptionsInit, {
isStream: true;
}>): Request;
(url: string | URL, options?: Options): CancelableRequest | Request;
(options: Options): CancelableRequest | Request;
}
(url: string | URL, options?: OptionsInit): CancelableRequest | Request;
(options: OptionsInit): CancelableRequest | Request;
(url: undefined, options: undefined, defaults: Options): CancelableRequest | Request;
};
/**
All available HTTP request methods provided by Got.
*/
export declare type HTTPAlias = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
interface GotStreamFunction {
(url: string | URL, options?: Merge<Options, {
isStream?: true;
}>): Request;
(options?: Merge<Options, {
isStream?: true;
}>): Request;
}
export type HTTPAlias = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
type GotStreamFunction = ((url?: string | URL, options?: Merge<OptionsInit, {
isStream?: true;
}>) => Request) & ((options?: Merge<OptionsInit, {
isStream?: true;
}>) => Request);
/**
An instance of `got.stream()`.
*/
export declare type GotStream = GotStreamFunction & Record<HTTPAlias, GotStreamFunction>;
export type GotStream = GotStreamFunction & Record<HTTPAlias, GotStreamFunction>;
/**
An instance of `got`.
*/
export interface Got extends Record<HTTPAlias, GotRequestFunction>, GotRequestFunction {
export type Got = {
/**

@@ -217,15 +219,15 @@ Sets `options.isStream` to `true`.

```
(async () => {
const countLimit = 10;
import got from 'got';
const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
pagination: {countLimit}
});
const countLimit = 10;
console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
pagination: {countLimit}
});
for await (const commitData of pagination) {
console.log(commitData.commit.message);
}
})();
console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
for await (const commitData of pagination) {
console.log(commitData.commit.message);
}
```

@@ -239,50 +241,2 @@ */

/**
An error to be thrown when a cache method fails. For example, if the database goes down or there's a filesystem error.
Contains a `code` property with `ERR_CACHE_ACCESS` or a more specific failure code.
*/
CacheError: typeof CacheError;
/**
An error to be thrown when a request fails. Contains a `code` property with error class code, like `ECONNREFUSED`.
If there is no specific code supplied, `code` defaults to `ERR_GOT_REQUEST_ERROR`.
*/
RequestError: typeof RequestError;
/**
An error to be thrown when reading from response stream fails. Contains a `code` property with
`ERR_READING_RESPONSE_STREAM` or a more specific failure code.
*/
ReadError: typeof ReadError;
/**
An error to be thrown when server response code is 2xx, and parsing body fails. Includes a
`response` property. Contains a `code` property with `ERR_BODY_PARSE_FAILURE` or a more specific failure code.
*/
ParseError: typeof ParseError;
/**
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. Contains a `code` property with `ERR_NON_2XX_3XX_RESPONSE` or a more specific failure code.
*/
HTTPError: typeof HTTPError;
/**
An error to be thrown when the server redirects you more than ten times.
Includes a `response` property. Contains a `code` property with `ERR_TOO_MANY_REDIRECTS`.
*/
MaxRedirectsError: typeof MaxRedirectsError;
/**
An error to be thrown when given an unsupported protocol. Contains a `code` property with `ERR_UNSUPPORTED_PROTOCOL`.
*/
UnsupportedProtocolError: typeof UnsupportedProtocolError;
/**
An error to be thrown when the request is aborted due to a timeout.
Includes an `event` and `timings` property. Contains a `code` property with `ETIMEDOUT`.
*/
TimeoutError: typeof TimeoutError;
/**
An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
Contains a `code` property with `ERR_UPLOAD` or a more specific failure code.
*/
UploadError: typeof UploadError;
/**
An error to be thrown when the request is aborted with `.cancel()`. Contains a `code` property with `ERR_CANCELED`.
*/
CancelError: typeof CancelError;
/**
Configure a new `got` instance with default `options`.

@@ -299,3 +253,5 @@ The `options` are merged with the parent instance's `defaults.options` using `got.mergeOptions`.

@example
```js
```
import got from 'got';
const client = got.extend({

@@ -317,41 +273,3 @@ prefixUrl: 'https://example.com',

extend: (...instancesOrOptions: Array<Got | ExtendOptions>) => Got;
/**
Merges multiple `got` instances into the parent.
*/
mergeInstances: (parent: Got, ...instances: Got[]) => Got;
/**
Extends parent options.
Avoid using [object spread](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax#Spread_in_object_literals) as it doesn't work recursively.
Options are deeply merged to a new object. The value of each key is determined as follows:
- If the new property is not defined, the old value is used.
- If the new property is explicitly set to `undefined`:
- If the parent property is a plain `object`, the parent value is deeply cloned.
- Otherwise, `undefined` is used.
- If the parent value is an instance of `URLSearchParams`:
- If the new value is a `string`, an `object` or an instance of `URLSearchParams`, a new `URLSearchParams` instance is created.
The values are merged using [`urlSearchParams.append(key, value)`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams/append).
The keys defined in the new value override the keys defined in the parent value.
- Otherwise, the only available value is `undefined`.
- If the new property is a plain `object`:
- 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.
- Otherwise, the new value is assigned to the key.
**Note:** Only Got options are merged! Custom user options should be defined via [`options.context`](#context).
@example
```
const a = {headers: {cat: 'meow', wolf: ['bark', 'wrrr']}};
const b = {headers: {cow: 'moo', wolf: ['auuu']}};
{...a, ...b} // => {headers: {cow: 'moo', wolf: ['auuu']}}
got.mergeOptions(a, b) // => {headers: {cat: 'meow', cow: 'moo', wolf: ['auuu']}}
```
*/
mergeOptions: (...sources: Options[]) => NormalizedOptions;
}
} & Record<HTTPAlias, GotRequestFunction> & GotRequestFunction;
export {};

3

dist/source/types.js

@@ -1,2 +0,1 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
export {};

137

package.json
{
"name": "got",
"version": "11.8.6",
"version": "14.0.0",
"description": "Human-friendly and powerful HTTP request library for Node.js",

@@ -8,8 +8,13 @@ "license": "MIT",

"funding": "https://github.com/sindresorhus/got?sponsor=1",
"main": "dist/source",
"type": "module",
"exports": {
"types": "./dist/source/index.d.ts",
"default": "./dist/source/index.js"
},
"sideEffects": false,
"engines": {
"node": ">=10.19.0"
"node": ">=20"
},
"scripts": {
"test": "xo && npm run build && nyc --reporter=html --reporter=text ava",
"test": "xo && tsc --noEmit && NODE_OPTIONS='--import=tsx/esm' ava",
"release": "np",

@@ -47,55 +52,57 @@ "build": "del-cli dist && tsc",

"dependencies": {
"@sindresorhus/is": "^4.0.0",
"@szmarczak/http-timer": "^4.0.5",
"@types/cacheable-request": "^6.0.1",
"@types/responselike": "^1.0.0",
"cacheable-lookup": "^5.0.3",
"cacheable-request": "^7.0.2",
"@sindresorhus/is": "^6.1.0",
"@szmarczak/http-timer": "^5.0.1",
"cacheable-lookup": "^7.0.0",
"cacheable-request": "^10.2.14",
"decompress-response": "^6.0.0",
"http2-wrapper": "^1.0.0-beta.5.2",
"lowercase-keys": "^2.0.0",
"p-cancelable": "^2.0.0",
"responselike": "^2.0.0"
"form-data-encoder": "^4.0.2",
"get-stream": "^8.0.1",
"http2-wrapper": "^2.2.1",
"lowercase-keys": "^3.0.0",
"p-cancelable": "^4.0.1",
"responselike": "^3.0.0"
},
"devDependencies": {
"@ava/typescript": "^1.1.1",
"@sindresorhus/tsconfig": "^0.7.0",
"@sinonjs/fake-timers": "^6.0.1",
"@types/benchmark": "^1.0.33",
"@types/express": "^4.17.7",
"@types/express-serve-static-core": "4.17.18 - 4.17.30",
"@types/node": "^14.14.0",
"@types/node-fetch": "^2.5.7",
"@types/pem": "^1.9.5",
"@types/pify": "^3.0.2",
"@types/request": "^2.48.5",
"@types/sinon": "^9.0.5",
"@types/tough-cookie": "^4.0.0",
"ava": "^3.11.1",
"axios": "^0.20.0",
"@hapi/bourne": "^3.0.0",
"@sindresorhus/tsconfig": "^5.0.0",
"@sinonjs/fake-timers": "^11.2.2",
"@types/benchmark": "^2.1.5",
"@types/express": "^4.17.21",
"@types/node": "^20.10.0",
"@types/pem": "^1.14.4",
"@types/readable-stream": "^4.0.9",
"@types/request": "^2.48.12",
"@types/sinon": "^17.0.2",
"@types/sinonjs__fake-timers": "^8.1.5",
"ava": "^5.3.1",
"axios": "^1.6.2",
"benchmark": "^2.1.4",
"coveralls": "^3.1.0",
"bluebird": "^3.7.2",
"body-parser": "^1.20.2",
"create-cert": "^1.0.6",
"create-test-server": "^3.0.1",
"del-cli": "^3.0.1",
"delay": "^4.4.0",
"express": "^4.17.1",
"form-data": "^3.0.0",
"get-stream": "^6.0.0",
"nock": "^13.0.4",
"node-fetch": "^2.6.0",
"np": "^6.4.0",
"del-cli": "^5.1.0",
"delay": "^6.0.0",
"express": "^4.18.2",
"form-data": "^4.0.0",
"formdata-node": "^6.0.3",
"nock": "^13.4.0",
"node-fetch": "^3.3.2",
"np": "^9.0.0",
"nyc": "^15.1.0",
"p-event": "^4.2.0",
"pem": "^1.14.4",
"pify": "^5.0.0",
"sinon": "^9.0.3",
"p-event": "^6.0.0",
"pem": "^1.14.8",
"pify": "^6.1.0",
"readable-stream": "^4.4.2",
"request": "^2.88.2",
"sinon": "^17.0.1",
"slow-stream": "0.0.4",
"tempy": "^1.0.0",
"to-readable-stream": "^2.1.0",
"tough-cookie": "^4.0.0",
"typescript": "4.0.3",
"xo": "^0.34.1"
"tempy": "^3.1.0",
"then-busboy": "^5.2.1",
"tough-cookie": "^4.1.3",
"tsx": "^4.6.0",
"type-fest": "^4.8.2",
"typescript": "^5.3.2",
"xo": "^0.56.0"
},
"types": "dist/source",
"sideEffects": false,
"ava": {

@@ -106,9 +113,13 @@ "files": [

"timeout": "1m",
"typescript": {
"rewritePaths": {
"test/": "dist/test/"
}
}
"extensions": {
"ts": "module"
},
"workerThreads": false
},
"nyc": {
"reporter": [
"text",
"html",
"lcov"
],
"extension": [

@@ -127,6 +138,16 @@ ".ts"

"@typescript-eslint/no-empty-function": "off",
"node/prefer-global/url": "off",
"node/prefer-global/url-search-params": "off",
"import/no-anonymous-default-export": "off",
"@typescript-eslint/no-implicit-any-catch": "off"
"n/no-deprecated-api": "off",
"@typescript-eslint/no-implicit-any-catch": "off",
"ava/assertion-arguments": "off",
"@typescript-eslint/no-unsafe-member-access": "off",
"@typescript-eslint/no-unsafe-return": "off",
"@typescript-eslint/no-unsafe-assignment": "off",
"@typescript-eslint/no-unsafe-call": "off",
"@typescript-eslint/await-thenable": "off",
"@typescript-eslint/no-redundant-type-constituents": "off",
"@typescript-eslint/no-unsafe-argument": "off",
"@typescript-eslint/promise-function-async": "off",
"no-lone-blocks": "off",
"unicorn/no-await-expression-member": "off",
"unicorn/prefer-event-target": "off"
}

@@ -133,0 +154,0 @@ },

dist/source/as-promise/create-rejection.d.ts
dist/source/as-promise/create-rejection.js
dist/source/as-promise/normalize-arguments.d.ts
dist/source/as-promise/normalize-arguments.js
dist/source/as-promise/parse-body.d.ts
dist/source/as-promise/parse-body.js
dist/source/core/utils/dns-ip-version.d.ts
dist/source/core/utils/dns-ip-version.js
dist/source/core/utils/get-buffer.d.ts
dist/source/core/utils/get-buffer.js
dist/source/core/utils/is-response-ok.d.ts
dist/source/core/utils/is-response-ok.js
dist/source/core/utils/timed-out.d.ts
dist/source/core/utils/timed-out.js
dist/source/utils/deep-freeze.d.ts
dist/source/utils/deep-freeze.js
dist/source/utils/deprecation-warning.d.ts
dist/source/utils/deprecation-warning.js
dist/source/core/index.js

Sorry, the diff of this file is too big to display

license

Sorry, the diff of this file is not supported yet

readme.md

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc