format: prettify entire project

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

@@ -1,110 +1,119 @@
-'use strict'
+'use strict';
 
-const { InvalidArgumentError, SocketError } = require('../core/errors')
-const { AsyncResource } = require('node:async_hooks')
-const assert = require('node:assert')
-const util = require('../core/util')
-const { addSignal, removeSignal } = require('./abort-signal')
+const { InvalidArgumentError, SocketError } = require('../core/errors');
+const { AsyncResource } = require('node:async_hooks');
+const assert = require('node:assert');
+const util = require('../core/util');
+const { addSignal, removeSignal } = require('./abort-signal');
 
 class UpgradeHandler 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_UPGRADE')
+    super('UNDICI_UPGRADE');
 
-    this.responseHeaders = responseHeaders || null
-    this.opaque = opaque || null
-    this.callback = callback
-    this.abort = null
-    this.context = null
+    this.responseHeaders = responseHeaders || null;
+    this.opaque = opaque || null;
+    this.callback = callback;
+    this.abort = null;
+    this.context = 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 = null
+    this.abort = abort;
+    this.context = null;
   }
 
-  onHeaders () {
-    throw new SocketError('bad upgrade', null)
+  onHeaders() {
+    throw new SocketError('bad upgrade', null);
   }
 
-  onUpgrade (statusCode, rawHeaders, socket) {
-    assert(statusCode === 101)
+  onUpgrade(statusCode, rawHeaders, socket) {
+    assert(statusCode === 101);
 
-    const { callback, opaque, context } = this
+    const { callback, opaque, context } = this;
 
-    removeSignal(this)
+    removeSignal(this);
 
-    this.callback = null
-    const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+    this.callback = null;
+    const headers =
+      this.responseHeaders === 'raw' ?
+        util.parseRawHeaders(rawHeaders)
+      : util.parseHeaders(rawHeaders);
     this.runInAsyncScope(callback, null, null, {
       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 upgrade (opts, callback) {
+function upgrade(opts, callback) {
   if (callback === undefined) {
     return new Promise((resolve, reject) => {
       upgrade.call(this, opts, (err, data) => {
-        return err ? reject(err) : resolve(data)
-      })
-    })
+        return err ? reject(err) : resolve(data);
+      });
+    });
   }
 
   try {
-    const upgradeHandler = new UpgradeHandler(opts, callback)
+    const upgradeHandler = new UpgradeHandler(opts, callback);
     const upgradeOpts = {
       ...opts,
       method: opts.method || 'GET',
-      upgrade: opts.protocol || 'Websocket'
-    }
+      upgrade: opts.protocol || 'Websocket',
+    };
 
-    this.dispatch(upgradeOpts, upgradeHandler)
+    this.dispatch(upgradeOpts, upgradeHandler);
   } 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 = upgrade
+module.exports = upgrade;