Code style

Author: sindresorhus

source/core/errors.ts

@@ -17,9 +17,9 @@ An error to be thrown when a request fails.
 Contains a `code` property with error class code, like `ECONNREFUSED`.
 */
 export class RequestError<T = unknown> extends Error {
+	override name = 'RequestError';
+	code = 'ERR_GOT_REQUEST_ERROR';
 	input?: string;
-
-	code: string;
 	override stack!: string;
 	declare readonly options: Options;
 	readonly response?: Response<T>;
@@ -30,8 +30,10 @@ export class RequestError<T = unknown> extends Error {
 		super(message, {cause: error});
 		Error.captureStackTrace(this, this.constructor);
 
-		this.name = 'RequestError';
-		this.code = error.code ?? 'ERR_GOT_REQUEST_ERROR';
+		if (error.code) {
+			this.code = error.code;
+		}
+
 		this.input = (error as any).input;
 
 		if (isRequest(self)) {
@@ -73,14 +75,14 @@ An error to be thrown when the server redirects you more than ten times.
 Includes a `response` property.
 */
 export class MaxRedirectsError extends RequestError {
+	override name = 'MaxRedirectsError';
+	override code = 'ERR_TOO_MANY_REDIRECTS';
 	declare readonly response: Response;
 	declare readonly request: Request;
 	declare readonly timings: Timings;
 
 	constructor(request: Request) {
 		super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
-		this.name = 'MaxRedirectsError';
-		this.code = 'ERR_TOO_MANY_REDIRECTS';
 	}
 }
 
@@ -91,14 +93,14 @@ Includes a `response` property.
 // TODO: Change `HTTPError<T = any>` to `HTTPError<T = unknown>` in the next major version to enforce type usage.
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export class HTTPError<T = any> extends RequestError<T> {
+	override name = 'HTTPError';
+	override code = 'ERR_NON_2XX_3XX_RESPONSE';
 	declare readonly response: Response<T>;
 	declare readonly request: Request;
 	declare readonly timings: Timings;
 
 	constructor(response: PlainResponse) {
 		super(`Request failed with status code ${response.statusCode} (${response.statusMessage!}): ${response.request.options.method} ${response.request.options.url!.toString()}`, {}, response.request);
-		this.name = 'HTTPError';
-		this.code = 'ERR_NON_2XX_3XX_RESPONSE';
 	}
 }
 
@@ -107,25 +109,29 @@ An error to be thrown when a cache method fails.
 For example, if the database goes down or there's a filesystem error.
 */
 export class CacheError extends RequestError {
+	override name = 'CacheError';
 	declare readonly request: Request;
 
 	constructor(error: Error, request: Request) {
 		super(error.message, error, request);
-		this.name = 'CacheError';
-		this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_CACHE_ACCESS' : this.code;
+		if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+			this.code = 'ERR_CACHE_ACCESS';
+		}
 	}
 }
 
 /**
 An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
 */
 export class UploadError extends RequestError {
+	override name = 'UploadError';
 	declare readonly request: Request;
 
 	constructor(error: Error, request: Request) {
 		super(error.message, error, request);
-		this.name = 'UploadError';
-		this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_UPLOAD' : this.code;
+		if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+			this.code = 'ERR_UPLOAD';
+		}
 	}
 }
 
@@ -134,13 +140,13 @@ An error to be thrown when the request is aborted due to a timeout.
 Includes an `event` and `timings` property.
 */
 export class TimeoutError extends RequestError {
+	override name = 'TimeoutError';
 	declare readonly request: Request;
 	override readonly timings: Timings;
 	readonly event: string;
 
 	constructor(error: TimedOutTimeoutError, timings: Timings, request: Request) {
 		super(error.message, error, request);
-		this.name = 'TimeoutError';
 		this.event = error.event;
 		this.timings = timings;
 	}
@@ -150,35 +156,39 @@ export class TimeoutError extends RequestError {
 An error to be thrown when reading from response stream fails.
 */
 export class ReadError extends RequestError {
+	override name = 'ReadError';
 	declare readonly request: Request;
 	declare readonly response: Response;
 	declare readonly timings: Timings;
 
 	constructor(error: Error, request: Request) {
 		super(error.message, error, request);
-		this.name = 'ReadError';
-		this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_READING_RESPONSE_STREAM' : this.code;
+		if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+			this.code = 'ERR_READING_RESPONSE_STREAM';
+		}
 	}
 }
 
 /**
 An error which always triggers a new retry when thrown.
 */
 export class RetryError extends RequestError {
+	override name = 'RetryError';
+	override code = 'ERR_RETRYING';
+
 	constructor(request: Request) {
 		super('Retrying', {}, request);
-		this.name = 'RetryError';
-		this.code = 'ERR_RETRYING';
 	}
 }
 
 /**
 An error to be thrown when the request is aborted by AbortController.
 */
 export class AbortError extends RequestError {
+	override name = 'AbortError';
+	override code = 'ERR_ABORTED';
+
 	constructor(request: Request) {
 		super('This operation was aborted.', {}, request);
-		this.code = 'ERR_ABORTED';
-		this.name = 'AbortError';
 	}
 }

source/core/index.ts

@@ -44,7 +44,6 @@ import {
 	AbortError,
 } from './errors.js';
 import {
-	type RequestId,
 	generateRequestId,
 	publishRequestCreate,
 	publishRequestStart,
@@ -187,34 +186,34 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 	options: Options;
 	response?: PlainResponse;
 	requestUrl?: URL;
-	redirectUrls: URL[];
-	retryCount: number;
-	_stopReading: boolean;
+	redirectUrls: URL[] = [];
+	retryCount = 0;
+	_stopReading = false;
 
 	declare private _requestOptions: NativeRequestOptions;
 
-	private _stopRetry: () => void;
-	private _downloadedSize: number;
-	private _uploadedSize: number;
-	private readonly _pipedServerResponses: Set<ServerResponse>;
+	private _stopRetry = noop;
+	private _downloadedSize = 0;
+	private _uploadedSize = 0;
+	private readonly _pipedServerResponses = new Set<ServerResponse>();
 	private _request?: ClientRequest;
 	private _responseSize?: number;
 	private _bodySize?: number;
-	private _unproxyEvents: () => void;
+	private _unproxyEvents = noop;
 	private _isFromCache?: boolean;
-	private _triggerRead: boolean;
-	declare private readonly _jobs: Array<() => void>;
-	private _cancelTimeouts: () => void;
-	private readonly _removeListeners: () => void;
+	private _triggerRead = false;
+	private readonly _jobs: Array<() => void> = [];
+	private _cancelTimeouts = noop;
+	private readonly _removeListeners = noop;
 	private _nativeResponse?: IncomingMessageWithTimings;
-	private _flushed: boolean;
-	private _aborted: boolean;
+	private _flushed = false;
+	private _aborted = false;
 	private _expectedContentLength?: number;
 	private _byteCounter?: ByteCounter;
-	private readonly _requestId: RequestId;
+	private readonly _requestId = generateRequestId();
 
 	// We need this because `this._request` if `undefined` when using cache
-	private _requestInitialized: boolean;
+	private _requestInitialized = false;
 
 	constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType) {
 		super({
@@ -224,25 +223,6 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 			highWaterMark: 0,
 		});
 
-		this._downloadedSize = 0;
-		this._uploadedSize = 0;
-		this._stopReading = false;
-		this._pipedServerResponses = new Set<ServerResponse>();
-		this._unproxyEvents = noop;
-		this._triggerRead = false;
-		this._cancelTimeouts = noop;
-		this._removeListeners = noop;
-		this._jobs = [];
-		this._flushed = false;
-		this._requestInitialized = false;
-		this._aborted = false;
-
-		this.redirectUrls = [];
-		this.retryCount = 0;
-
-		this._stopRetry = noop;
-		this._requestId = generateRequestId();
-
 		this.on('pipe', (source: NodeJS.ReadableStream & {headers?: Record<string, string | string[] | undefined>}) => {
 			if (this.options.copyPipedHeaders && source?.headers) {
 				Object.assign(this.options.headers, source.headers);

source/core/options.ts

@@ -1293,7 +1293,7 @@ const init = (options: OptionsInit, withOptions: OptionsInit, self: Options): vo
 export default class Options {
 	private _unixOptions?: NativeRequestOptions;
 	private readonly _internals: InternalsType;
-	private _merging: boolean;
+	private _merging = false;
 	private readonly _init: OptionsInit[];
 
 	constructor(input?: string | URL | OptionsInit, options?: OptionsInit, defaults?: Options) {
@@ -1307,8 +1307,6 @@ export default class Options {
 
 		this._internals = cloneInternals(defaults?._internals ?? defaults ?? defaultInternals);
 		this._init = [...(defaults?._init ?? [])];
-		this._merging = false;
-		this._unixOptions = undefined;
 
 		// This rule allows `finally` to be considered more important.
 		// Meaning no matter the error thrown in the `try` block,

source/core/response.ts

@@ -126,14 +126,14 @@ An error to be thrown when server response code is 2xx, and parsing body fails.
 Includes a `response` property.
 */
 export class ParseError extends RequestError {
+	override name = 'ParseError';
+	override code = 'ERR_BODY_PARSE_FAILURE';
 	declare readonly response: Response;
 
 	constructor(error: Error, response: Response) {
 		const {options} = response.request;
 
 		super(`${error.message} in "${options.url!.toString()}"`, error, response.request);
-		this.name = 'ParseError';
-		this.code = 'ERR_BODY_PARSE_FAILURE';
 	}
 }
 

source/core/timed-out.ts

@@ -33,13 +33,11 @@ export type ErrorCode =
 	| 'EAI_AGAIN';
 
 export class TimeoutError extends Error {
-	code: ErrorCode;
+	override name = 'TimeoutError';
+	code: ErrorCode = 'ETIMEDOUT';
 
 	constructor(threshold: number, public event: string) {
 		super(`Timeout awaiting '${event}' for ${threshold}ms`);
-
-		this.name = 'TimeoutError';
-		this.code = 'ETIMEDOUT';
 	}
 }
 

source/core/utils/weakable-map.ts

@@ -1,11 +1,6 @@
 export default class WeakableMap<K, V> {
-	weakMap: WeakMap<Record<string, unknown>, V>;
-	map: Map<K, V>;
-
-	constructor() {
-		this.weakMap = new WeakMap();
-		this.map = new Map();
-	}
+	weakMap = new WeakMap<Record<string, unknown>, V>();
+	map = new Map<K, V>();
 
 	set(key: K, value: V): void {
 		if (typeof key === 'object') {