format: prettify entire project

node_modules/undici/lib/api/api-connect.js

@@ -1,64 +1,73 @@
-'use strict'
+'use strict';
 
-const assert = require('node:assert')
-const { AsyncResource } = require('node:async_hooks')
-const { InvalidArgumentError, SocketError } = require('../core/errors')
-const util = require('../core/util')
-const { addSignal, removeSignal } = require('./abort-signal')
+const assert = require('node:assert');
+const { AsyncResource } = require('node:async_hooks');
+const { InvalidArgumentError, SocketError } = require('../core/errors');
+const util = require('../core/util');
+const { addSignal, removeSignal } = require('./abort-signal');
 
 class ConnectHandler extends AsyncResource {
-  constructor (opts, callback) {
+  constructor(opts, callback) {
     if (!opts || typeof opts !== 'object') {
-      throw new InvalidArgumentError('invalid opts')
+      throw new InvalidArgumentError('invalid opts');
     }
 
     if (typeof callback !== 'function') {
-      throw new InvalidArgumentError('invalid callback')
+      throw new InvalidArgumentError('invalid callback');
     }
 
-    const { signal, opaque, responseHeaders } = opts
+    const { signal, opaque, responseHeaders } = opts;
 
-    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
-      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+    if (
+      signal &&
+      typeof signal.on !== 'function' &&
+      typeof signal.addEventListener !== 'function'
+    ) {
+      throw new InvalidArgumentError(
+        'signal must be an EventEmitter or EventTarget'
+      );
     }
 
-    super('UNDICI_CONNECT')
+    super('UNDICI_CONNECT');
 
-    this.opaque = opaque || null
-    this.responseHeaders = responseHeaders || null
-    this.callback = callback
-    this.abort = null
+    this.opaque = opaque || null;
+    this.responseHeaders = responseHeaders || null;
+    this.callback = callback;
+    this.abort = null;
 
-    addSignal(this, signal)
+    addSignal(this, signal);
   }
 
-  onConnect (abort, context) {
+  onConnect(abort, context) {
     if (this.reason) {
-      abort(this.reason)
-      return
+      abort(this.reason);
+      return;
     }
 
-    assert(this.callback)
+    assert(this.callback);
 
-    this.abort = abort
-    this.context = context
+    this.abort = abort;
+    this.context = context;
   }
 
-  onHeaders () {
-    throw new SocketError('bad connect', null)
+  onHeaders() {
+    throw new SocketError('bad connect', null);
   }
 
-  onUpgrade (statusCode, rawHeaders, socket) {
-    const { callback, opaque, context } = this
+  onUpgrade(statusCode, rawHeaders, socket) {
+    const { callback, opaque, context } = this;
 
-    removeSignal(this)
+    removeSignal(this);
 
-    this.callback = null
+    this.callback = null;
 
-    let headers = rawHeaders
+    let headers = rawHeaders;
     // Indicates is an HTTP2Session
     if (headers != null) {
-      headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+      headers =
+        this.responseHeaders === 'raw' ?
+          util.parseRawHeaders(rawHeaders)
+        : util.parseHeaders(rawHeaders);
     }
 
     this.runInAsyncScope(callback, null, null, {
@@ -66,45 +75,45 @@ class ConnectHandler extends AsyncResource {
       headers,
       socket,
       opaque,
-      context
-    })
+      context,
+    });
   }
 
-  onError (err) {
-    const { callback, opaque } = this
+  onError(err) {
+    const { callback, opaque } = this;
 
-    removeSignal(this)
+    removeSignal(this);
 
     if (callback) {
-      this.callback = null
+      this.callback = null;
       queueMicrotask(() => {
-        this.runInAsyncScope(callback, null, err, { opaque })
-      })
+        this.runInAsyncScope(callback, null, err, { opaque });
+      });
     }
   }
 }
 
-function connect (opts, callback) {
+function connect(opts, callback) {
   if (callback === undefined) {
     return new Promise((resolve, reject) => {
       connect.call(this, opts, (err, data) => {
-        return err ? reject(err) : resolve(data)
-      })
-    })
+        return err ? reject(err) : resolve(data);
+      });
+    });
   }
 
   try {
-    const connectHandler = new ConnectHandler(opts, callback)
-    const connectOptions = { ...opts, method: 'CONNECT' }
+    const connectHandler = new ConnectHandler(opts, callback);
+    const connectOptions = { ...opts, method: 'CONNECT' };
 
-    this.dispatch(connectOptions, connectHandler)
+    this.dispatch(connectOptions, connectHandler);
   } catch (err) {
     if (typeof callback !== 'function') {
-      throw err
+      throw err;
     }
-    const opaque = opts?.opaque
-    queueMicrotask(() => callback(err, { opaque }))
+    const opaque = opts?.opaque;
+    queueMicrotask(() => callback(err, { opaque }));
   }
 }
 
-module.exports = connect
+module.exports = connect;