got 10.5.7 → 11.0.0

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+interface FormData extends Readable {
+    getBoundary(): string;
+    getLength(callback: (error: Error | null, length: number) => void): void;
+}
+declare const _default: (body: unknown) => body is FormData;
+export default _default;

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

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { URL } from 'url';
+export interface URLOptions {
+    href?: string;
+    protocol?: string;
+    host?: string;
+    hostname?: string;
+    port?: string | number;
+    pathname?: string;
+    search?: string;
+    searchParams?: unknown;
+    path?: string;
+}
+declare const _default: (origin: string, options: URLOptions) => URL;
+export default _default;

package/dist/source/{utils → core/utils}/options-to-url.js

@@ -1,27 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file: deprecated */
 const url_1 = require("url");
-function validateSearchParams(searchParams) {
-    for (const value of Object.values(searchParams)) {
-        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean' && value !== null) {
-            throw new TypeError(`The \`searchParams\` value '${String(value)}' must be a string, number, boolean or null`);
-        }
-    }
-}
 const keys = [
     'protocol',
-    'username',
-    'password',
     'host',
     'hostname',
     'port',
     'pathname',
-    'search',
-    'hash'
+    'search'
 ];
-exports.default = (options) => {
+exports.default = (origin, options) => {
     var _a, _b;
-    let origin;
     if (options.path) {
         if (options.pathname) {
             throw new TypeError('Parameters `path` and `pathname` are mutually exclusive.');
@@ -33,19 +23,10 @@ exports.default = (options) => {
             throw new TypeError('Parameters `path` and `searchParams` are mutually exclusive.');
         }
     }
-    if (Reflect.has(options, 'auth')) {
-        throw new TypeError('Parameter `auth` is deprecated. Use `username` / `password` instead.');
-    }
     if (options.search && options.searchParams) {
         throw new TypeError('Parameters `search` and `searchParams` are mutually exclusive.');
     }
-    if (options.href) {
-        return new url_1.URL(options.href);
-    }
-    if (options.origin) {
-        origin = options.origin;
-    }
-    else {
+    if (!origin) {
         if (!options.protocol) {
             throw new TypeError('No URL protocol specified');
         }
@@ -61,22 +42,12 @@ exports.default = (options) => {
             options.pathname = options.path.slice(0, searchIndex);
             options.search = options.path.slice(searchIndex + 1);
         }
-    }
-    if (Reflect.has(options, 'path')) {
         delete options.path;
     }
     for (const key of keys) {
-        if (Reflect.has(options, key)) {
+        if (options[key]) {
             url[key] = options[key].toString();
         }
     }
-    if (options.searchParams) {
-        if (typeof options.searchParams !== 'string' && !(options.searchParams instanceof url_1.URLSearchParams)) {
-            validateSearchParams(options.searchParams);
-        }
-        (new url_1.URLSearchParams(options.searchParams)).forEach((value, key) => {
-            url.searchParams.append(key, value);
-        });
-    }
     return url;
 };

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

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export default function (from: EventEmitter, to: EventEmitter, events: string[]): () => void;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(from, to, events) {
+    const fns = {};
+    for (const event of events) {
+        fns[event] = (...args) => {
+            to.emit(event, ...args);
+        };
+        from.on(event, fns[event]);
+    }
+    return () => {
+        for (const event of events) {
+            from.off(event, fns[event]);
+        }
+    };
+}
+exports.default = default_1;

package/dist/source/{utils → core/utils}/timed-out.js

@@ -14,7 +14,7 @@ class TimeoutError extends Error {
 }
 exports.TimeoutError = TimeoutError;
 exports.default = (request, delays, options) => {
-    if (Reflect.has(request, reentry)) {
+    if (reentry in request) {
         return noop;
     }
     request[reentry] = true;
@@ -33,11 +33,9 @@ exports.default = (request, delays, options) => {
     const { host, hostname } = options;
     const timeoutHandler = (delay, event) => {
         if (request.socket) {
-            // @ts-ignore We do not want the `socket hang up` error
             request.socket._hadError = true;
         }
-        request.abort();
-        request.emit('error', new TimeoutError(delay, event));
+        request.destroy(new TimeoutError(delay, event));
     };
     const cancelTimeouts = () => {
         for (const cancel of cancelers) {
@@ -73,7 +71,6 @@ exports.default = (request, delays, options) => {
     }
     once(request, 'socket', (socket) => {
         var _a;
-        // @ts-ignore Node typings doesn't have this property
         const { socketPath } = request;
         /* istanbul ignore next: hard to test */
         if (socket.connecting) {

package/dist/source/{utils → core/utils}/unhandle.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import EventEmitter = require('events');
+import { EventEmitter } from 'events';
 declare type Origin = EventEmitter;
 declare type Event = string | symbol;
 declare type Fn = (...args: any[]) => void;

package/dist/source/core/utils/weakable-map.d.ts

@@ -0,0 +1,8 @@
+export default class WeakableMap<K, V> {
+    weakMap: WeakMap<object, V>;
+    map: Map<K, V>;
+    constructor();
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class WeakableMap {
+    constructor() {
+        this.weakMap = new WeakMap();
+        this.map = new Map();
+    }
+    set(key, value) {
+        if (typeof key === 'object') {
+            this.weakMap.set(key, value);
+        }
+        else {
+            this.map.set(key, value);
+        }
+    }
+    get(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.get(key);
+        }
+        return this.map.get(key);
+    }
+    has(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.has(key);
+        }
+        return this.map.has(key);
+    }
+}
+exports.default = WeakableMap;

package/dist/source/create.d.ts

@@ -1,81 +1,5 @@
-/// <reference types="node" />
-import { Merge } from 'type-fest';
-import { ProxyStream } from './as-stream';
-import * as errors from './errors';
-import { CancelableRequest, Defaults, ExtendOptions, HandlerFunction, NormalizedOptions, Options, Response, URLOrOptions, PaginationOptions } from './types';
-export declare type HTTPAlias = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
-export declare type ReturnStream = <T>(url: string | Merge<Options, {
-    isStream?: true;
-}>, options?: Merge<Options, {
-    isStream?: true;
-}>) => ProxyStream<T>;
-export declare type GotReturn<T = unknown> = CancelableRequest<T> | ProxyStream<T>;
-export declare type OptionsOfDefaultResponseBody = Merge<Options, {
-    isStream?: false;
-    resolveBodyOnly?: false;
-    responseType?: 'default';
-}>;
-declare type OptionsOfTextResponseBody = Merge<Options, {
-    isStream?: false;
-    resolveBodyOnly?: false;
-    responseType: 'text';
-}>;
-declare type OptionsOfJSONResponseBody = Merge<Options, {
-    isStream?: false;
-    resolveBodyOnly?: false;
-    responseType: 'json';
-}>;
-declare type OptionsOfBufferResponseBody = Merge<Options, {
-    isStream?: false;
-    resolveBodyOnly?: false;
-    responseType: 'buffer';
-}>;
-declare type ResponseBodyOnly = {
-    resolveBodyOnly: true;
-};
-/**
-Can be used to match methods explicitly or parameters extraction: `Parameters<GotRequestMethod>`.
-*/
-export interface GotRequestMethod {
-    <T = string>(url: string | OptionsOfDefaultResponseBody, options?: OptionsOfDefaultResponseBody): CancelableRequest<Response<T>>;
-    (url: string | OptionsOfTextResponseBody, options?: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
-    <T>(url: string | OptionsOfJSONResponseBody, options?: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;
-    (url: string | OptionsOfBufferResponseBody, options?: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
-    <T = string>(url: string | Merge<OptionsOfDefaultResponseBody, ResponseBodyOnly>, options?: Merge<OptionsOfDefaultResponseBody, ResponseBodyOnly>): CancelableRequest<T>;
-    (url: string | Merge<OptionsOfTextResponseBody, ResponseBodyOnly>, options?: Merge<OptionsOfTextResponseBody, ResponseBodyOnly>): CancelableRequest<string>;
-    <T>(url: string | Merge<OptionsOfJSONResponseBody, ResponseBodyOnly>, options?: Merge<OptionsOfJSONResponseBody, ResponseBodyOnly>): CancelableRequest<T>;
-    (url: string | Merge<OptionsOfBufferResponseBody, ResponseBodyOnly>, options?: Merge<OptionsOfBufferResponseBody, ResponseBodyOnly>): CancelableRequest<Buffer>;
-    <T>(url: string | Merge<Options, {
-        isStream: true;
-    }>, options?: Merge<Options, {
-        isStream: true;
-    }>): ProxyStream<T>;
-}
-export interface GotPaginate {
-    <T>(url: URLOrOptions & PaginationOptions<T>, options?: Options & PaginationOptions<T>): AsyncIterableIterator<T>;
-    all<T>(url: URLOrOptions & PaginationOptions<T>, options?: Options & PaginationOptions<T>): Promise<T[]>;
-}
-export interface Got extends Record<HTTPAlias, GotRequestMethod>, GotRequestMethod {
-    stream: GotStream;
-    paginate: GotPaginate;
-    defaults: Defaults;
-    GotError: typeof errors.GotError;
-    CacheError: typeof errors.CacheError;
-    RequestError: typeof errors.RequestError;
-    ReadError: typeof errors.ReadError;
-    ParseError: typeof errors.ParseError;
-    HTTPError: typeof errors.HTTPError;
-    MaxRedirectsError: typeof errors.MaxRedirectsError;
-    UnsupportedProtocolError: typeof errors.UnsupportedProtocolError;
-    TimeoutError: typeof errors.TimeoutError;
-    CancelError: typeof errors.CancelError;
-    extend(...instancesOrOptions: Array<Got | ExtendOptions>): Got;
-    mergeInstances(parent: Got, ...instances: Got[]): Got;
-    mergeOptions(...sources: Options[]): NormalizedOptions;
-}
-export interface GotStream extends Record<HTTPAlias, ReturnStream> {
-    (url: URLOrOptions, options?: Options): ProxyStream;
-}
+import { Got, HandlerFunction, InstanceDefaults } from './types';
 export declare const defaultHandler: HandlerFunction;
-declare const create: (defaults: Defaults) => Got;
+declare const create: (defaults: InstanceDefaults) => Got;
 export default create;
+export * from './types';

package/dist/source/create.js

@@ -1,13 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const p_cancelable_1 = require("p-cancelable");
 const is_1 = require("@sindresorhus/is");
 const as_promise_1 = require("./as-promise");
-const as_stream_1 = require("./as-stream");
-const errors = require("./errors");
-const normalize_arguments_1 = require("./normalize-arguments");
+const create_rejection_1 = require("./as-promise/create-rejection");
+const core_1 = require("./core");
 const deep_freeze_1 = require("./utils/deep-freeze");
-const getPromiseOrStream = (options) => options.isStream ? as_stream_1.default(options) : as_promise_1.default(options);
-const isGotInstance = (value) => (Reflect.has(value, 'defaults') && Reflect.has(value.defaults, 'options'));
+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: p_cancelable_1.CancelError,
+    UnsupportedProtocolError: as_promise_1.UnsupportedProtocolError,
+    UploadError: as_promise_1.UploadError
+};
+const { normalizeArguments, mergeOptions } = as_promise_1.PromisableRequest;
+const getPromiseOrStream = (options) => options.isStream ? new core_1.default(options.url, options) : as_promise_1.default(options);
+const isGotInstance = (value) => ('defaults' in value && 'options' in value.defaults);
 const aliases = [
     'get',
     'post',
@@ -17,6 +30,13 @@ const aliases = [
     '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;
@@ -40,28 +60,50 @@ const create = (defaults) => {
         }
         return result;
     }));
-    // @ts-ignore Because the for loop handles it for us, as well as the other Object.defines
-    const got = (url, options) => {
-        var _a;
+    const got = ((url, options = {}) => {
+        var _a, _b, _c, _d, _e;
         let iteration = 0;
         const iterateHandlers = (newOptions) => {
             return defaults.handlers[iteration++](newOptions, iteration === defaults.handlers.length ? getPromiseOrStream : iterateHandlers);
         };
-        /* eslint-disable @typescript-eslint/return-await */
+        if (is_1.default.plainObject(url)) {
+            options = {
+                ...url,
+                ...options
+            };
+            url = undefined;
+        }
         try {
-            return iterateHandlers(normalize_arguments_1.normalizeArguments(url, options, defaults));
+            // Call `init` hooks
+            let initHookError;
+            try {
+                callInitHooks(defaults.options.hooks.init, options);
+                callInitHooks((_b = (_a = options) === null || _a === void 0 ? void 0 : _a.hooks) === null || _b === void 0 ? void 0 : _b.init, options);
+            }
+            catch (error) {
+                initHookError = error;
+            }
+            // Normalize options & call handlers
+            const normalizedOptions = normalizeArguments(url, options, defaults.options);
+            normalizedOptions[core_1.kIsNormalizedAlready] = true;
+            if (initHookError) {
+                throw new as_promise_1.RequestError(initHookError.message, initHookError, normalizedOptions);
+            }
+            // A bug.
+            // eslint-disable-next-line @typescript-eslint/return-await
+            return iterateHandlers(normalizedOptions);
         }
         catch (error) {
-            if ((_a = options) === null || _a === void 0 ? void 0 : _a.isStream) {
+            if ((_c = options) === null || _c === void 0 ? void 0 : _c.isStream) {
                 throw error;
             }
             else {
-                // @ts-ignore It's an Error not a response, but TS thinks it's calling .resolve
-                return as_promise_1.createRejection(error);
+                // A bug.
+                // eslint-disable-next-line @typescript-eslint/return-await
+                return create_rejection_1.default(error, defaults.options.hooks.beforeError, (_e = (_d = options) === null || _d === void 0 ? void 0 : _d.hooks) === null || _e === void 0 ? void 0 : _e.beforeError);
             }
         }
-        /* eslint-enable @typescript-eslint/return-await */
-    };
+    });
     got.extend = (...instancesOrOptions) => {
         const optionsArray = [defaults.options];
         let handlers = [...defaults._rawHandlers];
@@ -74,7 +116,7 @@ const create = (defaults) => {
             }
             else {
                 optionsArray.push(value);
-                if (Reflect.has(value, 'handlers')) {
+                if ('handlers' in value) {
                     handlers.push(...value.handlers);
                 }
                 isMutableDefaults = value.mutableDefaults;
@@ -85,61 +127,63 @@ const create = (defaults) => {
             handlers.push(exports.defaultHandler);
         }
         return create({
-            options: normalize_arguments_1.mergeOptions(...optionsArray),
+            options: mergeOptions(...optionsArray),
             handlers,
             mutableDefaults: Boolean(isMutableDefaults)
         });
     };
-    // @ts-ignore The missing methods because the for-loop handles it for us
-    got.stream = (url, options) => got(url, { ...options, isStream: true });
-    for (const method of aliases) {
-        // @ts-ignore Cannot properly type a function with multiple definitions yet
-        got[method] = (url, options) => got(url, { ...options, method });
-        got.stream[method] = (url, options) => got.stream(url, { ...options, method });
-    }
-    // @ts-ignore The missing property is added below
-    got.paginate = async function* (url, options) {
-        let normalizedOptions = normalize_arguments_1.normalizeArguments(url, options, defaults);
-        const pagination = normalizedOptions._pagination;
+    got.paginate = (async function* (url, options) {
+        let normalizedOptions = normalizeArguments(url, options, defaults.options);
+        normalizedOptions.resolveBodyOnly = false;
+        const pagination = normalizedOptions.pagination;
         if (!is_1.default.object(pagination)) {
-            throw new Error('`options._pagination` must be implemented');
+            throw new TypeError('`options.pagination` must be implemented');
         }
         const all = [];
         while (true) {
-            // @ts-ignore See https://github.com/sindresorhus/got/issues/954
+            // TODO: Throw when result is not an instance of Response
             // eslint-disable-next-line no-await-in-loop
-            const result = await got(normalizedOptions);
+            const result = (await got('', normalizedOptions));
             // eslint-disable-next-line no-await-in-loop
             const parsed = await pagination.transform(result);
+            const current = [];
             for (const item of parsed) {
-                if (pagination.filter(item, all)) {
-                    if (!pagination.shouldContinue(item, all)) {
+                if (pagination.filter(item, all, current)) {
+                    if (!pagination.shouldContinue(item, all, current)) {
                         return;
                     }
                     yield item;
                     all.push(item);
+                    current.push(item);
                     if (all.length === pagination.countLimit) {
                         return;
                     }
                 }
             }
-            const optionsToMerge = pagination.paginate(result);
+            const optionsToMerge = pagination.paginate(result, all, current);
             if (optionsToMerge === false) {
                 return;
             }
             if (optionsToMerge !== undefined) {
-                normalizedOptions = normalize_arguments_1.normalizeArguments(normalizedOptions, optionsToMerge);
+                normalizedOptions = normalizeArguments(undefined, optionsToMerge, normalizedOptions);
             }
         }
-    };
-    got.paginate.all = async (url, options) => {
+    });
+    got.paginate.all = (async (url, options) => {
         const results = [];
         for await (const item of got.paginate(url, options)) {
             results.push(item);
         }
         return results;
-    };
-    Object.assign(got, { ...errors, mergeOptions: normalize_arguments_1.mergeOptions });
+    });
+    got.stream = ((url, options) => got(url, { ...options, isStream: true }));
+    for (const method of aliases) {
+        got[method] = ((url, options) => got(url, { ...options, method }));
+        got.stream[method] = ((url, options) => {
+            return got(url, { ...options, method, isStream: true });
+        });
+    }
+    Object.assign(got, { ...errors, mergeOptions });
     Object.defineProperty(got, 'defaults', {
         value: defaults.mutableDefaults ? defaults : deep_freeze_1.default(defaults),
         writable: defaults.mutableDefaults,

package/dist/source/index.d.ts

@@ -1,7 +1,4 @@
-declare const got: import("./create").Got;
+declare const got: import("./types").Got;
 export default got;
-export * from './types';
-export { Got, GotStream, ReturnStream, GotRequestMethod, GotReturn } from './create';
-export { ProxyStream as ResponseStream } from './as-stream';
-export { GotError, CacheError, RequestError, ReadError, ParseError, HTTPError, MaxRedirectsError, UnsupportedProtocolError, TimeoutError, CancelError } from './errors';
-export { InitHook, BeforeRequestHook, BeforeRedirectHook, BeforeRetryHook, BeforeErrorHook, AfterResponseHook, HookType, Hooks, HookEvent } from './known-hook-events';
+export * from './create';
+export * from './as-promise';

package/dist/source/index.js

@@ -4,6 +4,7 @@ function __export(m) {
 }
 Object.defineProperty(exports, "__esModule", { value: true });
 const url_1 = require("url");
+const cacheable_lookup_1 = require("cacheable-lookup");
 const create_1 = require("./create");
 const defaults = {
     options: {
@@ -55,13 +56,12 @@ const defaults = {
             beforeError: [],
             afterResponse: []
         },
+        cache: undefined,
+        dnsCache: new cacheable_lookup_1.default(),
         decompress: true,
         throwHttpErrors: true,
         followRedirect: true,
         isStream: false,
-        cache: false,
-        dnsCache: false,
-        useElectronNet: false,
         responseType: 'text',
         resolveBodyOnly: false,
         maxRedirects: 10,
@@ -69,8 +69,15 @@ const defaults = {
         methodRewriting: true,
         ignoreInvalidCookies: false,
         context: {},
-        _pagination: {
+        // TODO: Set this to `true` when Got 12 gets released
+        http2: false,
+        allowGetBody: false,
+        rejectUnauthorized: true,
+        pagination: {
             transform: (response) => {
+                if (response.request.options.responseType === 'json') {
+                    return response.body;
+                }
                 return JSON.parse(response.body);
             },
             paginate: response => {
@@ -108,18 +115,5 @@ exports.default = got;
 // For CommonJS default export support
 module.exports = got;
 module.exports.default = got;
-// Export types
-__export(require("./types"));
-var as_stream_1 = require("./as-stream");
-exports.ResponseStream = as_stream_1.ProxyStream;
-var errors_1 = require("./errors");
-exports.GotError = errors_1.GotError;
-exports.CacheError = errors_1.CacheError;
-exports.RequestError = errors_1.RequestError;
-exports.ReadError = errors_1.ReadError;
-exports.ParseError = errors_1.ParseError;
-exports.HTTPError = errors_1.HTTPError;
-exports.MaxRedirectsError = errors_1.MaxRedirectsError;
-exports.UnsupportedProtocolError = errors_1.UnsupportedProtocolError;
-exports.TimeoutError = errors_1.TimeoutError;
-exports.CancelError = errors_1.CancelError;
+__export(require("./create"));
+__export(require("./as-promise"));