got 10.5.7 → 11.0.0

package/dist/source/as-promise.js

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const EventEmitter = require("events");
-const getStream = require("get-stream");
-const PCancelable = require("p-cancelable");
-const is_1 = require("@sindresorhus/is");
-const errors_1 = require("./errors");
-const normalize_arguments_1 = require("./normalize-arguments");
-const request_as_event_emitter_1 = require("./request-as-event-emitter");
-const parseBody = (body, responseType, encoding) => {
-    if (responseType === 'json') {
-        return body.length === 0 ? '' : JSON.parse(body.toString());
-    }
-    if (responseType === 'buffer') {
-        return Buffer.from(body);
-    }
-    if (responseType === 'text') {
-        return body.toString(encoding);
-    }
-    throw new TypeError(`Unknown body type '${responseType}'`);
-};
-function createRejection(error) {
-    const promise = Promise.reject(error);
-    const returnPromise = () => promise;
-    promise.json = returnPromise;
-    promise.text = returnPromise;
-    promise.buffer = returnPromise;
-    promise.on = returnPromise;
-    return promise;
-}
-exports.createRejection = createRejection;
-function asPromise(options) {
-    const proxy = new EventEmitter();
-    let body;
-    const promise = new PCancelable((resolve, reject, onCancel) => {
-        const emitter = request_as_event_emitter_1.default(options);
-        onCancel(emitter.abort);
-        const emitError = async (error) => {
-            try {
-                for (const hook of options.hooks.beforeError) {
-                    // eslint-disable-next-line no-await-in-loop
-                    error = await hook(error);
-                }
-                reject(error);
-            }
-            catch (error_) {
-                reject(error_);
-            }
-        };
-        emitter.on('response', async (response) => {
-            var _a;
-            proxy.emit('response', response);
-            // Download body
-            try {
-                body = await getStream.buffer(response, { encoding: 'binary' });
-            }
-            catch (error) {
-                emitError(new errors_1.ReadError(error, options));
-                return;
-            }
-            if ((_a = response.req) === null || _a === void 0 ? void 0 : _a.aborted) {
-                // Canceled while downloading - will throw a `CancelError` or `TimeoutError` error
-                return;
-            }
-            const isOk = () => {
-                const { statusCode } = response;
-                const limitStatusCode = options.followRedirect ? 299 : 399;
-                return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
-            };
-            // Parse body
-            try {
-                response.body = parseBody(body, options.responseType, options.encoding);
-            }
-            catch (error) {
-                // Fall back to `utf8`
-                response.body = body.toString();
-                if (isOk()) {
-                    const parseError = new errors_1.ParseError(error, response, options);
-                    emitError(parseError);
-                    return;
-                }
-            }
-            try {
-                for (const [index, hook] of options.hooks.afterResponse.entries()) {
-                    // @ts-ignore 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 = normalize_arguments_1.normalizeArguments(normalize_arguments_1.mergeOptions(options, {
-                            ...updatedOptions,
-                            retry: {
-                                calculateDelay: () => 0
-                            },
-                            throwHttpErrors: false,
-                            resolveBodyOnly: false
-                        }));
-                        // 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 = options.hooks.afterResponse.slice(0, index);
-                        for (const hook of options.hooks.beforeRetry) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await hook(typedOptions);
-                        }
-                        const promise = asPromise(typedOptions);
-                        onCancel(() => {
-                            promise.catch(() => { });
-                            promise.cancel();
-                        });
-                        return promise;
-                    });
-                }
-            }
-            catch (error) {
-                emitError(error);
-                return;
-            }
-            // Check for HTTP error codes
-            if (!isOk()) {
-                const error = new errors_1.HTTPError(response, options);
-                if (emitter.retry(error)) {
-                    return;
-                }
-                if (options.throwHttpErrors) {
-                    emitError(error);
-                    return;
-                }
-            }
-            resolve(options.resolveBodyOnly ? response.body : response);
-        });
-        emitter.once('error', reject);
-        request_as_event_emitter_1.proxyEvents(proxy, emitter);
-    });
-    promise.on = (name, fn) => {
-        proxy.on(name, fn);
-        return promise;
-    };
-    const shortcut = (responseType) => {
-        // eslint-disable-next-line promise/prefer-await-to-then
-        const newPromise = promise.then(() => parseBody(body, responseType, options.encoding));
-        Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
-        return newPromise;
-    };
-    promise.json = () => {
-        if (is_1.default.undefined(body) && is_1.default.undefined(options.headers.accept)) {
-            options.headers.accept = 'application/json';
-        }
-        return shortcut('json');
-    };
-    promise.buffer = () => shortcut('buffer');
-    promise.text = () => shortcut('text');
-    return promise;
-}
-exports.default = asPromise;

package/dist/source/as-stream.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-import { Duplex as DuplexStream } from 'stream';
-import { GotEvents, NormalizedOptions } from './types';
-export declare class ProxyStream<T = unknown> extends DuplexStream implements GotEvents<ProxyStream<T>> {
-    isFromCache?: boolean;
-}
-export default function asStream<T>(options: NormalizedOptions): ProxyStream<T>;

package/dist/source/as-stream.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const duplexer3 = require("duplexer3");
-const http_1 = require("http");
-const stream_1 = require("stream");
-const errors_1 = require("./errors");
-const request_as_event_emitter_1 = require("./request-as-event-emitter");
-class ProxyStream extends stream_1.Duplex {
-}
-exports.ProxyStream = ProxyStream;
-function asStream(options) {
-    const input = new stream_1.PassThrough();
-    const output = new stream_1.PassThrough();
-    const proxy = duplexer3(input, output);
-    const piped = new Set();
-    let isFinished = false;
-    options.retry.calculateDelay = () => 0;
-    if (options.body || options.json || options.form) {
-        proxy.write = () => {
-            proxy.destroy();
-            throw new Error('Got\'s stream is not writable when the `body`, `json` or `form` option is used');
-        };
-    }
-    else if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
-        options.body = input;
-    }
-    else {
-        proxy.write = () => {
-            proxy.destroy();
-            throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
-        };
-    }
-    const emitter = request_as_event_emitter_1.default(options);
-    const emitError = async (error) => {
-        try {
-            for (const hook of options.hooks.beforeError) {
-                // eslint-disable-next-line no-await-in-loop
-                error = await hook(error);
-            }
-            proxy.emit('error', error);
-        }
-        catch (error_) {
-            proxy.emit('error', error_);
-        }
-    };
-    // Cancels the request
-    proxy._destroy = (error, callback) => {
-        callback(error);
-        emitter.abort();
-    };
-    emitter.on('response', (response) => {
-        const { statusCode, isFromCache } = response;
-        proxy.isFromCache = isFromCache;
-        if (options.throwHttpErrors && statusCode !== 304 && (statusCode < 200 || statusCode > 299)) {
-            emitError(new errors_1.HTTPError(response, options));
-            return;
-        }
-        {
-            const read = proxy._read;
-            proxy._read = (...args) => {
-                isFinished = true;
-                proxy._read = read;
-                return read.apply(proxy, args);
-            };
-        }
-        if (options.encoding) {
-            proxy.setEncoding(options.encoding);
-        }
-        // We cannot use `stream.pipeline(...)` here,
-        // because if we did then `output` would throw
-        // the original error before throwing `ReadError`.
-        response.pipe(output);
-        response.once('error', error => {
-            emitError(new errors_1.ReadError(error, options));
-        });
-        for (const destination of piped) {
-            if (destination.headersSent) {
-                continue;
-            }
-            for (const [key, value] of Object.entries(response.headers)) {
-                // Got gives *decompressed* data. Overriding `content-encoding` header would result in an error.
-                // It's not possible to decompress already decompressed data, is it?
-                const isAllowed = options.decompress ? key !== 'content-encoding' : true;
-                if (isAllowed) {
-                    destination.setHeader(key, value);
-                }
-            }
-            destination.statusCode = response.statusCode;
-        }
-        proxy.emit('response', response);
-    });
-    request_as_event_emitter_1.proxyEvents(proxy, emitter);
-    emitter.on('error', (error) => proxy.emit('error', error));
-    const pipe = proxy.pipe.bind(proxy);
-    const unpipe = proxy.unpipe.bind(proxy);
-    proxy.pipe = (destination, options) => {
-        if (isFinished) {
-            throw new Error('Failed to pipe. The response has been emitted already.');
-        }
-        pipe(destination, options);
-        if (destination instanceof http_1.ServerResponse) {
-            piped.add(destination);
-        }
-        return destination;
-    };
-    proxy.unpipe = stream => {
-        piped.delete(stream);
-        return unpipe(stream);
-    };
-    proxy.on('pipe', source => {
-        if (source instanceof http_1.IncomingMessage) {
-            options.headers = {
-                ...source.headers,
-                ...options.headers
-            };
-        }
-    });
-    proxy.isFromCache = undefined;
-    return proxy;
-}
-exports.default = asStream;

package/dist/source/errors.d.ts

@@ -1,41 +0,0 @@
-import { Timings } from '@szmarczak/http-timer';
-import { TimeoutError as TimedOutError } from './utils/timed-out';
-import { Response, NormalizedOptions } from './types';
-export declare class GotError extends Error {
-    code?: string;
-    stack: string;
-    readonly options: NormalizedOptions;
-    constructor(message: string, error: Partial<Error & {
-        code?: string;
-    }>, options: NormalizedOptions);
-}
-export declare class CacheError extends GotError {
-    constructor(error: Error, options: NormalizedOptions);
-}
-export declare class RequestError extends GotError {
-    constructor(error: Error, options: NormalizedOptions);
-}
-export declare class ReadError extends GotError {
-    constructor(error: Error, options: NormalizedOptions);
-}
-export declare class ParseError extends GotError {
-    readonly response: Response;
-    constructor(error: Error, response: Response, options: NormalizedOptions);
-}
-export declare class HTTPError extends GotError {
-    readonly response: Response;
-    constructor(response: Response, options: NormalizedOptions);
-}
-export declare class MaxRedirectsError extends GotError {
-    readonly response: Response;
-    constructor(response: Response, maxRedirects: number, options: NormalizedOptions);
-}
-export declare class UnsupportedProtocolError extends GotError {
-    constructor(options: NormalizedOptions);
-}
-export declare class TimeoutError extends GotError {
-    timings: Timings;
-    event: string;
-    constructor(error: TimedOutError, timings: Timings, options: NormalizedOptions);
-}
-export { CancelError } from 'p-cancelable';

package/dist/source/errors.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_1 = require("@sindresorhus/is");
-class GotError extends Error {
-    constructor(message, error, options) {
-        super(message);
-        Error.captureStackTrace(this, this.constructor);
-        this.name = 'GotError';
-        if (!is_1.default.undefined(error.code)) {
-            this.code = error.code;
-        }
-        Object.defineProperty(this, 'options', {
-            // This fails because of TS 3.7.2 useDefineForClassFields
-            // Ref: https://github.com/microsoft/TypeScript/issues/34972
-            enumerable: false,
-            value: options
-        });
-        // Recover the original stacktrace
-        if (!is_1.default.undefined(error.stack)) {
-            const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
-            const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
-            const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse();
-            // Remove duplicated traces
-            while (errorStackTrace.length !== 0 && errorStackTrace[0] === thisStackTrace[0]) {
-                thisStackTrace.shift();
-            }
-            this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
-        }
-    }
-}
-exports.GotError = GotError;
-class CacheError extends GotError {
-    constructor(error, options) {
-        super(error.message, error, options);
-        this.name = 'CacheError';
-    }
-}
-exports.CacheError = CacheError;
-class RequestError extends GotError {
-    constructor(error, options) {
-        super(error.message, error, options);
-        this.name = 'RequestError';
-    }
-}
-exports.RequestError = RequestError;
-class ReadError extends GotError {
-    constructor(error, options) {
-        super(error.message, error, options);
-        this.name = 'ReadError';
-    }
-}
-exports.ReadError = ReadError;
-class ParseError extends GotError {
-    constructor(error, response, options) {
-        super(`${error.message} in "${options.url.toString()}"`, error, options);
-        this.name = 'ParseError';
-        Object.defineProperty(this, 'response', {
-            enumerable: false,
-            value: response
-        });
-    }
-}
-exports.ParseError = ParseError;
-class HTTPError extends GotError {
-    constructor(response, options) {
-        super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, options);
-        this.name = 'HTTPError';
-        Object.defineProperty(this, 'response', {
-            enumerable: false,
-            value: response
-        });
-    }
-}
-exports.HTTPError = HTTPError;
-class MaxRedirectsError extends GotError {
-    constructor(response, maxRedirects, options) {
-        super(`Redirected ${maxRedirects} times. Aborting.`, {}, options);
-        this.name = 'MaxRedirectsError';
-        Object.defineProperty(this, 'response', {
-            enumerable: false,
-            value: response
-        });
-    }
-}
-exports.MaxRedirectsError = MaxRedirectsError;
-class UnsupportedProtocolError extends GotError {
-    constructor(options) {
-        super(`Unsupported protocol "${options.url.protocol}"`, {}, options);
-        this.name = 'UnsupportedProtocolError';
-    }
-}
-exports.UnsupportedProtocolError = UnsupportedProtocolError;
-class TimeoutError extends GotError {
-    constructor(error, timings, options) {
-        super(error.message, error, options);
-        this.name = 'TimeoutError';
-        this.event = error.event;
-        this.timings = timings;
-    }
-}
-exports.TimeoutError = TimeoutError;
-var p_cancelable_1 = require("p-cancelable");
-exports.CancelError = p_cancelable_1.CancelError;

package/dist/source/get-response.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-import EventEmitter = require('events');
-import { IncomingMessage } from 'http';
-import { NormalizedOptions } from './types';
-declare const _default: (response: IncomingMessage, options: NormalizedOptions, emitter: EventEmitter) => Promise<void>;
-export default _default;

package/dist/source/get-response.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const decompressResponse = require("decompress-response");
-const mimicResponse = require("mimic-response");
-const stream = require("stream");
-const util_1 = require("util");
-const progress_1 = require("./progress");
-const pipeline = util_1.promisify(stream.pipeline);
-exports.default = async (response, options, emitter) => {
-    var _a;
-    const downloadBodySize = Number(response.headers['content-length']) || undefined;
-    const progressStream = progress_1.createProgressStream('downloadProgress', emitter, downloadBodySize);
-    mimicResponse(response, progressStream);
-    const newResponse = (options.decompress &&
-        options.method !== 'HEAD' ? decompressResponse(progressStream) : progressStream);
-    if (!options.decompress && ['gzip', 'deflate', 'br'].includes((_a = newResponse.headers['content-encoding'], (_a !== null && _a !== void 0 ? _a : '')))) {
-        options.responseType = 'buffer';
-    }
-    emitter.emit('response', newResponse);
-    return pipeline(response, progressStream).catch(error => {
-        if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-            throw error;
-        }
-    });
-};

package/dist/source/known-hook-events.d.ts

@@ -1,88 +0,0 @@
-import { CancelableRequest, GeneralError, NormalizedOptions, Options, Response } from './types';
-/**
-Called with plain request options, right before their normalization. This is especially useful in conjunction with `got.extend()` when the input needs custom handling.
-
-**Note:** This hook must be synchronous.
-
-@see [Request migration guide](https://github.com/sindresorhus/got/blob/master/migration-guides.md#breaking-changes) for an example.
-*/
-export declare type InitHook = (options: Options) => void;
-/**
-Called with normalized [request options](https://github.com/sindresorhus/got#options). Got will make no further changes to the request before it is sent (except the body serialization). This is especially useful in conjunction with [`got.extend()`](https://github.com/sindresorhus/got#instances) when you want to create an API client that, for example, uses HMAC-signing.
-
-@see [AWS section](https://github.com/sindresorhus/got#aws) for an example.
-*/
-export declare type BeforeRequestHook = (options: NormalizedOptions) => void | Promise<void>;
-/**
-Called with normalized [request options](https://github.com/sindresorhus/got#options). Got will make no further changes to the request. This is especially useful when you want to avoid dead sites.
-*/
-export declare type BeforeRedirectHook = (options: NormalizedOptions, response: Response) => void | Promise<void>;
-/**
-Called with normalized [request options](https://github.com/sindresorhus/got#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.
-*/
-export declare type BeforeRetryHook = (options: NormalizedOptions, error?: GeneralError, retryCount?: number) => void | Promise<void>;
-/**
-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.
-*/
-export declare type BeforeErrorHook = <ErrorLike extends GeneralError>(error: ErrorLike) => GeneralError | Promise<GeneralError>;
-/**
-Called with [response object](https://github.com/sindresorhus/got#response) and a retry function.
-
-Each function should return the response. This is especially useful when you want to refresh an access token.
-*/
-export declare type AfterResponseHook = (response: Response, retryWithMergedOptions: (options: Options) => CancelableRequest<Response>) => Response | CancelableRequest<Response> | Promise<Response | CancelableRequest<Response>>;
-export declare type HookType = BeforeErrorHook | InitHook | BeforeRequestHook | BeforeRedirectHook | BeforeRetryHook | AfterResponseHook;
-/**
-Hooks allow modifications during the request lifecycle. Hook functions may be async and are run serially.
-*/
-export interface Hooks {
-    /**
-    Called with plain request options, right before their normalization. This is especially useful in conjunction with `got.extend()` when the input needs custom handling.
-
-    **Note:** This hook must be synchronous.
-
-    @see [Request migration guide](https://github.com/sindresorhus/got/blob/master/migration-guides.md#breaking-changes) for an example.
-    @default []
-    */
-    init?: InitHook[];
-    /**
-    Called with normalized [request options](https://github.com/sindresorhus/got#options). Got will make no further changes to the request before it is sent (except the body serialization). This is especially useful in conjunction with [`got.extend()`](https://github.com/sindresorhus/got#instances) when you want to create an API client that, for example, uses HMAC-signing.
-
-    @see [AWS section](https://github.com/sindresorhus/got#aws) for an example.
-    @default []
-    */
-    beforeRequest?: BeforeRequestHook[];
-    /**
-    Called with normalized [request options](https://github.com/sindresorhus/got#options). Got will make no further changes to the request. This is especially useful when you want to avoid dead sites.
-
-    @default []
-    */
-    beforeRedirect?: BeforeRedirectHook[];
-    /**
-    Called with normalized [request options](https://github.com/sindresorhus/got#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.
-
-    @default []
-    */
-    beforeRetry?: BeforeRetryHook[];
-    /**
-    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 []
-    */
-    beforeError?: BeforeErrorHook[];
-    /**
-    Called with [response object](https://github.com/sindresorhus/got#response) and a retry function.
-
-    Each function should return the response. This is especially useful when you want to refresh an access token.
-
-    @default []
-    */
-    afterResponse?: AfterResponseHook[];
-}
-export declare type HookEvent = keyof Hooks;
-declare const knownHookEvents: readonly HookEvent[];
-export default knownHookEvents;

package/dist/source/known-hook-events.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const knownHookEvents = [
-    'beforeError',
-    'init',
-    'beforeRequest',
-    'beforeRedirect',
-    'beforeRetry',
-    'afterResponse'
-];
-exports.default = knownHookEvents;

package/dist/source/normalize-arguments.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="node" />
-import http = require('http');
-import https = require('https');
-import stream = require('stream');
-import { Merge } from 'type-fest';
-import { Defaults, NormalizedOptions, RequestFunction, URLOrOptions, requestSymbol } from './types';
-export declare const preNormalizeArguments: (options: Merge<https.RequestOptions, Merge<import("./types").GotOptions, import("./utils/options-to-url").URLOptions>>, defaults?: NormalizedOptions | undefined) => NormalizedOptions;
-export declare const mergeOptions: (...sources: Merge<https.RequestOptions, Merge<import("./types").GotOptions, import("./utils/options-to-url").URLOptions>>[]) => NormalizedOptions;
-export declare const normalizeArguments: (url: URLOrOptions, options?: Merge<https.RequestOptions, Merge<import("./types").GotOptions, import("./utils/options-to-url").URLOptions>> | undefined, defaults?: Defaults | undefined) => NormalizedOptions;
-export declare type NormalizedRequestArguments = Merge<https.RequestOptions, {
-    body?: stream.Readable;
-    [requestSymbol]: RequestFunction;
-    url: Pick<NormalizedOptions, 'url'>;
-}>;
-export declare const normalizeRequestArguments: (options: NormalizedOptions) => Promise<Merge<https.RequestOptions, {
-    body?: stream.Readable | undefined;
-    url: Pick<NormalizedOptions, "url">;
-    [requestSymbol]: typeof http.request;
-}>>;