undici 6.21.0 → 7.0.0-alpha.10

package/lib/dispatcher/dispatcher.js

@@ -1,5 +1,8 @@
 'use strict'
 const EventEmitter = require('node:events')
+const WrapHandler = require('../handler/wrap-handler')
+
+const wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler))
 
 class Dispatcher extends EventEmitter {
   dispatch () {
@@ -29,36 +32,16 @@ class Dispatcher extends EventEmitter {
       }
 
       dispatch = interceptor(dispatch)
+      dispatch = wrapInterceptor(dispatch)
 
       if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
         throw new TypeError('invalid interceptor')
       }
     }
 
-    return new ComposedDispatcher(this, dispatch)
-  }
-}
-
-class ComposedDispatcher extends Dispatcher {
-  #dispatcher = null
-  #dispatch = null
-
-  constructor (dispatcher, dispatch) {
-    super()
-    this.#dispatcher = dispatcher
-    this.#dispatch = dispatch
-  }
-
-  dispatch (...args) {
-    this.#dispatch(...args)
-  }
-
-  close (...args) {
-    return this.#dispatcher.close(...args)
-  }
-
-  destroy (...args) {
-    return this.#dispatcher.destroy(...args)
+    return new Proxy(this, {
+      get: (target, key) => key === 'dispatch' ? dispatch : target[key]
+    })
   }
 }
 

package/lib/dispatcher/fixed-queue.js

@@ -1,12 +1,10 @@
-/* eslint-disable */
-
 'use strict'
 
 // Extracted from node/lib/internal/fixed_queue.js
 
 // Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
-const kSize = 2048;
-const kMask = kSize - 1;
+const kSize = 2048
+const kMask = kSize - 1
 
 // The FixedQueue is implemented as a singly-linked list of fixed-size
 // circular buffers. It looks something like this:
@@ -17,18 +15,18 @@ const kMask = kSize - 1;
 // +-----------+ <-----\       +-----------+ <------\         +-----------+
 // |  [null]   |        \----- |   next    |         \------- |   next    |
 // +-----------+               +-----------+                  +-----------+
-// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
-// |   item    |               |   item    |                  |  [empty]  |
-// |   item    |               |   item    |                  |  [empty]  |
-// |   item    |               |   item    |                  |  [empty]  |
+// |   item    | <-- bottom    |   item    | <-- bottom       | undefined |
+// |   item    |               |   item    |                  | undefined |
+// |   item    |               |   item    |                  | undefined |
+// |   item    |               |   item    |                  | undefined |
 // |   item    |               |   item    |       bottom --> |   item    |
 // |   item    |               |   item    |                  |   item    |
 // |    ...    |               |    ...    |                  |    ...    |
 // |   item    |               |   item    |                  |   item    |
 // |   item    |               |   item    |                  |   item    |
-// |  [empty]  | <-- top       |   item    |                  |   item    |
-// |  [empty]  |               |   item    |                  |   item    |
-// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
+// | undefined | <-- top       |   item    |                  |   item    |
+// | undefined |               |   item    |                  |   item    |
+// | undefined |               | undefined | <-- top  top --> | undefined |
 // +-----------+               +-----------+                  +-----------+
 //
 // Or, if there is only one circular buffer, it looks something
@@ -40,12 +38,12 @@ const kMask = kSize - 1;
 // +-----------+                               +-----------+
 // |  [null]   |                               |  [null]   |
 // +-----------+                               +-----------+
-// |  [empty]  |                               |   item    |
-// |  [empty]  |                               |   item    |
-// |   item    | <-- bottom            top --> |  [empty]  |
-// |   item    |                               |  [empty]  |
-// |  [empty]  | <-- top            bottom --> |   item    |
-// |  [empty]  |                               |   item    |
+// | undefined |                               |   item    |
+// | undefined |                               |   item    |
+// |   item    | <-- bottom            top --> | undefined |
+// |   item    |                               | undefined |
+// | undefined | <-- top            bottom --> |   item    |
+// | undefined |                               |   item    |
 // +-----------+                               +-----------+
 //
 // Adding a value means moving `top` forward by one, removing means
@@ -56,62 +54,106 @@ const kMask = kSize - 1;
 // `top + 1 === bottom` it's full. This wastes a single space of storage
 // but allows much quicker checks.
 
+/**
+ * @type {FixedCircularBuffer}
+ * @template T
+ */
 class FixedCircularBuffer {
-  constructor() {
-    this.bottom = 0;
-    this.top = 0;
-    this.list = new Array(kSize);
-    this.next = null;
+  constructor () {
+    /**
+     * @type {number}
+     */
+    this.bottom = 0
+    /**
+     * @type {number}
+     */
+    this.top = 0
+    /**
+     * @type {Array<T|undefined>}
+     */
+    this.list = new Array(kSize).fill(undefined)
+    /**
+     * @type {T|null}
+     */
+    this.next = null
   }
 
-  isEmpty() {
-    return this.top === this.bottom;
+  /**
+   * @returns {boolean}
+   */
+  isEmpty () {
+    return this.top === this.bottom
   }
 
-  isFull() {
-    return ((this.top + 1) & kMask) === this.bottom;
+  /**
+   * @returns {boolean}
+   */
+  isFull () {
+    return ((this.top + 1) & kMask) === this.bottom
   }
 
-  push(data) {
-    this.list[this.top] = data;
-    this.top = (this.top + 1) & kMask;
+  /**
+   * @param {T} data
+   * @returns {void}
+   */
+  push (data) {
+    this.list[this.top] = data
+    this.top = (this.top + 1) & kMask
   }
 
-  shift() {
-    const nextItem = this.list[this.bottom];
-    if (nextItem === undefined)
-      return null;
-    this.list[this.bottom] = undefined;
-    this.bottom = (this.bottom + 1) & kMask;
-    return nextItem;
+  /**
+   * @returns {T|null}
+   */
+  shift () {
+    const nextItem = this.list[this.bottom]
+    if (nextItem === undefined) { return null }
+    this.list[this.bottom] = undefined
+    this.bottom = (this.bottom + 1) & kMask
+    return nextItem
   }
 }
 
+/**
+ * @template T
+ */
 module.exports = class FixedQueue {
-  constructor() {
-    this.head = this.tail = new FixedCircularBuffer();
+  constructor () {
+    /**
+     * @type {FixedCircularBuffer<T>}
+     */
+    this.head = this.tail = new FixedCircularBuffer()
   }
 
-  isEmpty() {
-    return this.head.isEmpty();
+  /**
+   * @returns {boolean}
+   */
+  isEmpty () {
+    return this.head.isEmpty()
   }
 
-  push(data) {
+  /**
+   * @param {T} data
+   */
+  push (data) {
     if (this.head.isFull()) {
       // Head is full: Creates a new queue, sets the old queue's `.next` to it,
       // and sets it as the new main queue.
-      this.head = this.head.next = new FixedCircularBuffer();
+      this.head = this.head.next = new FixedCircularBuffer()
     }
-    this.head.push(data);
+    this.head.push(data)
   }
 
-  shift() {
-    const tail = this.tail;
-    const next = tail.shift();
+  /**
+   * @returns {T|null}
+   */
+  shift () {
+    const tail = this.tail
+    const next = tail.shift()
     if (tail.isEmpty() && tail.next !== null) {
       // If there is another queue, it forms the new tail.
-      this.tail = tail.next;
+      this.tail = tail.next
+      tail.next = null
     }
-    return next;
+    return next
   }
-};
+}

package/lib/dispatcher/pool-stats.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require('../core/symbols')
 const kPool = Symbol('pool')
 

package/lib/dispatcher/pool.js

@@ -12,7 +12,7 @@ const {
   InvalidArgumentError
 } = require('../core/errors')
 const util = require('../core/util')
-const { kUrl, kInterceptors } = require('../core/symbols')
+const { kUrl } = require('../core/symbols')
 const buildConnector = require('../core/connect')
 
 const kOptions = Symbol('options')
@@ -37,8 +37,6 @@ class Pool extends PoolBase {
     allowH2,
     ...options
   } = {}) {
-    super()
-
     if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
       throw new InvalidArgumentError('invalid connections')
     }
@@ -51,6 +49,8 @@ class Pool extends PoolBase {
       throw new InvalidArgumentError('connect must be a function or an object')
     }
 
+    super()
+
     if (typeof connect !== 'function') {
       connect = buildConnector({
         ...tls,
@@ -63,9 +63,6 @@ class Pool extends PoolBase {
       })
     }
 
-    this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool)
-      ? options.interceptors.Pool
-      : []
     this[kConnections] = connections || null
     this[kUrl] = util.parseOrigin(origin)
     this[kOptions] = { ...util.deepClone(options), connect, allowH2 }

package/lib/dispatcher/proxy-agent.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { kProxy, kClose, kDestroy, kInterceptors } = require('../core/symbols')
+const { kProxy, kClose, kDestroy } = require('../core/symbols')
 const { URL } = require('node:url')
 const Agent = require('./agent')
 const Pool = require('./pool')
@@ -27,8 +27,6 @@ const noop = () => {}
 
 class ProxyAgent extends DispatcherBase {
   constructor (opts) {
-    super()
-
     if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
       throw new InvalidArgumentError('Proxy uri is mandatory')
     }
@@ -38,13 +36,12 @@ class ProxyAgent extends DispatcherBase {
       throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
     }
 
+    super()
+
     const url = this.#getUrl(opts)
     const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url
 
     this[kProxy] = { uri: href, protocol }
-    this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent)
-      ? opts.interceptors.ProxyAgent
-      : []
     this[kRequestTls] = opts.requestTls
     this[kProxyTls] = opts.proxyTls
     this[kProxyHeaders] = opts.headers || {}