Require Node.js 12.20.0 and move to ESM

.github/FUNDING.yml

@@ -1,6 +1,6 @@
 # These are supported funding model platforms
 
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github: node-fetch # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: # Replace with a single Patreon username
 open_collective: node-fetch # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username

@types/index.d.ts

@@ -1,16 +1,16 @@
 /// <reference types="node" />
 
-/* eslint-disable no-var, import/no-mutable-exports */
+/* eslint-disable node/prefer-global/url, node/prefer-global/url-search-params, no-redeclare */
 
-import { Agent } from 'http';
-import { URL, URLSearchParams } from 'url'
+import {Agent} from 'http';
+import {URL, URLSearchParams} from 'url';
 import Blob = require('fetch-blob');
 
 type AbortSignal = {
 	readonly aborted: boolean;
 
-	addEventListener(type: "abort", listener: (this: AbortSignal) => void): void;
-	removeEventListener(type: "abort", listener: (this: AbortSignal) => void): void;
+	addEventListener: (type: 'abort', listener: (this: AbortSignal) => void) => void;
+	removeEventListener: (type: 'abort', listener: (this: AbortSignal) => void) => void;
 };
 
 type HeadersInit = Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>;
@@ -100,9 +100,9 @@ type BodyInit =
 	| URLSearchParams
 	| NodeJS.ReadableStream
 	| string;
-type BodyType = { [K in keyof Body]: Body[K] };
+type BodyType = {[K in keyof Body]: Body[K]};
 declare class Body {
-	constructor(body?: BodyInit, opts?: { size?: number });
+	constructor(body?: BodyInit, options?: {size?: number});
 
 	readonly body: NodeJS.ReadableStream | null;
 	readonly bodyUsed: boolean;
@@ -143,7 +143,7 @@ declare class Request extends Body {
 	clone(): Request;
 }
 
-type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"
+type ResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
 
 declare class Response extends Body {
 	constructor(body?: BodyInit | null, init?: ResponseInit);
@@ -161,7 +161,7 @@ declare class Response extends Body {
 }
 
 declare class FetchError extends Error {
-	constructor(message: string, type: string, systemError?: object);
+	constructor(message: string, type: string, systemError?: Record<string, unknown>);
 
 	name: 'FetchError';
 	[Symbol.toStringTag]: 'FetchError';
@@ -176,28 +176,20 @@ declare class AbortError extends Error {
 	[Symbol.toStringTag]: 'AbortError';
 }
 
-
 declare function fetch(url: RequestInfo, init?: RequestInit): Promise<Response>;
-declare class fetch {
-	static default: typeof fetch;
-}
 declare namespace fetch {
 	export function isRedirect(code: number): boolean;
 
 	export {
 		HeadersInit,
 		Headers,
-
 		RequestInit,
 		RequestRedirect,
 		RequestInfo,
 		Request,
-
 		BodyInit,
-
 		ResponseInit,
 		Response,
-
 		FetchError,
 		AbortError
 	};

@types/index.test-d.ts

@@ -1,46 +1,46 @@
-import { expectType, expectAssignable } from 'tsd';
+import {expectType, expectAssignable} from 'tsd';
 import AbortController from 'abort-controller';
 import Blob = require('fetch-blob');
 
-import fetch, { Request, Response, Headers, Body, FetchError, AbortError } from '.';
+import fetch, {Request, Response, Headers, Body, FetchError, AbortError} from '.';
+// eslint-disable-next-line @typescript-eslint/no-duplicate-imports
 import * as _fetch from '.';
-import __fetch = require('.');
 
 async function run() {
-	const getRes = await fetch('https://bigfile.com/test.zip');
-	expectType<boolean>(getRes.ok);
-	expectType<number>(getRes.size);
-	expectType<number>(getRes.status);
-	expectType<string>(getRes.statusText);
-	expectType<() => Response>(getRes.clone);
+	const getResponse = await fetch('https://bigfile.com/test.zip');
+	expectType<boolean>(getResponse.ok);
+	expectType<number>(getResponse.size);
+	expectType<number>(getResponse.status);
+	expectType<string>(getResponse.statusText);
+	expectType<() => Response>(getResponse.clone);
 
 	// Test async iterator over body
-	expectType<NodeJS.ReadableStream | null>(getRes.body);
-	if (getRes.body) {
-		for await (const data of getRes.body) {
+	expectType<NodeJS.ReadableStream | null>(getResponse.body);
+	if (getResponse.body) {
+		for await (const data of getResponse.body) {
 			expectType<Buffer | string>(data);
 		}
 	}
 
 	// Test Buffer
-	expectType<Buffer>(await getRes.buffer());
+	expectType<Buffer>(await getResponse.buffer());
 
 	// Test arrayBuffer
-	expectType<ArrayBuffer>(await getRes.arrayBuffer());
+	expectType<ArrayBuffer>(await getResponse.arrayBuffer());
 
 	// Test JSON, returns unknown
-	expectType<unknown>(await getRes.json());
+	expectType<unknown>(await getResponse.json());
 
 	// Headers iterable
-	expectType<Headers>(getRes.headers);
+	expectType<Headers>(getResponse.headers);
 
 	// Post
 	try {
 		const request = new Request('http://byjka.com/buka');
 		expectType<string>(request.url);
 		expectType<Headers>(request.headers);
 
-		const headers = new Headers({ byaka: 'buke' });
+		const headers = new Headers({byaka: 'buke'});
 		expectType<(a: string, b: string) => void>(headers.append);
 		expectType<(a: string) => string | null>(headers.get);
 		expectType<(name: string, value: string) => void>(headers.set);
@@ -49,11 +49,11 @@ async function run() {
 		expectType<() => IterableIterator<[string, string]>>(headers.entries);
 		expectType<() => IterableIterator<[string, string]>>(headers[Symbol.iterator]);
 
-		const postRes = await fetch(request, { method: 'POST', headers });
-		expectType<Blob>(await postRes.blob());
-	} catch (error) {
+		const postResponse = await fetch(request, {method: 'POST', headers});
+		expectType<Blob>(await postResponse.blob());
+	} catch (error: unknown) {
 		if (error instanceof FetchError) {
-			throw new TypeError(error.errno);
+			throw new TypeError(error.errno as string | undefined);
 		}
 
 		if (error instanceof AbortError) {
@@ -62,31 +62,24 @@ async function run() {
 	}
 
 	// export *
-	const wildRes = await _fetch('https://google.com');
-	expectType<boolean>(wildRes.ok);
-	expectType<number>(wildRes.size);
-	expectType<number>(wildRes.status);
-	expectType<string>(wildRes.statusText);
-	expectType<() => Response>(wildRes.clone);
-
-	// export = require
-	const reqRes = await __fetch('https://google.com');
-	expectType<boolean>(reqRes.ok);
-	expectType<number>(reqRes.size);
-	expectType<number>(reqRes.status);
-	expectType<string>(reqRes.statusText);
-	expectType<() => Response>(reqRes.clone);
+	const wildResponse = await _fetch('https://google.com');
+	expectType<boolean>(wildResponse.ok);
+	expectType<number>(wildResponse.size);
+	expectType<number>(wildResponse.status);
+	expectType<string>(wildResponse.statusText);
+	expectType<() => Response>(wildResponse.clone);
 
 	// Others
 	const response = new Response();
 	expectType<string>(response.url);
 	expectAssignable<Body>(response);
 
-	const abortController = new AbortController()
-	const request = new Request('url', { signal: abortController.signal });
+	const abortController = new AbortController();
+	const request = new Request('url', {signal: abortController.signal});
 	expectAssignable<Body>(request);
 
-	new Headers({ 'Header': 'value' });
+	/* eslint-disable no-new */
+	new Headers({Header: 'value'});
 	// new Headers(['header', 'value']); // should not work
 	new Headers([['header', 'value']]);
 	new Headers(new Headers());
@@ -95,8 +88,9 @@ async function run() {
 		['b', '2'],
 		new Map([['a', null], ['3', null]]).keys()
 	]);
+	/* eslint-enable no-new */
 
-	fetch.isRedirect = (code: number) => true;
+	fetch.isRedirect = () => true;
 }
 
 run().finally(() => {