@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/lib/dispatcher/dispatcher-base.js

@@ -1,70 +1,61 @@
 'use strict'
 
-const buffer = require('node:buffer')
 const Dispatcher = require('./dispatcher')
 const {
   ClientDestroyedError,
   ClientClosedError,
   InvalidArgumentError
 } = require('../core/errors')
-const { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require('../core/symbols')
+const { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = require('../core/symbols')
 
 const kOnDestroyed = Symbol('onDestroyed')
 const kOnClosed = Symbol('onClosed')
+const kInterceptedDispatch = Symbol('Intercepted Dispatch')
 const kWebSocketOptions = Symbol('webSocketOptions')
-const kEventSourceOptions = Symbol('eventSourceOptions')
 
 class DispatcherBase extends Dispatcher {
-  /** @type {boolean} */
-  [kDestroyed] = false;
-
-  /** @type {Array<Function|null} */
-  [kOnDestroyed] = null;
-
-  /** @type {boolean} */
-  [kClosed] = false;
-
-  /** @type {Array<Function>|null} */
-  [kOnClosed] = null
-
-  /**
-   * @param {import('../../types/dispatcher').DispatcherOptions} [opts]
-   */
   constructor (opts) {
     super()
+
+    this[kDestroyed] = false
+    this[kOnDestroyed] = null
+    this[kClosed] = false
+    this[kOnClosed] = []
     this[kWebSocketOptions] = opts?.webSocket ?? {}
-    this[kEventSourceOptions] = opts?.eventSource ?? {}
   }
 
-  /**
-   * @returns {import('../../types/client').Client.WebSocketOptions}
-   */
   get webSocketOptions () {
     return {
       maxFragments: this[kWebSocketOptions].maxFragments ?? 131072,
-      maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024 // 128 MB default
-    }
-  }
-
-  /**
-   * @returns {import('../../types/client').Client.EventSourceOptions}
-   */
-  get eventSourceOptions () {
-    return {
-      maxEventSize: this[kEventSourceOptions].maxEventSize ?? buffer.kStringMaxLength
+      maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024
     }
   }
 
-  /** @returns {boolean} */
   get destroyed () {
     return this[kDestroyed]
   }
 
-  /** @returns {boolean} */
   get closed () {
     return this[kClosed]
   }
 
+  get interceptors () {
+    return this[kInterceptors]
+  }
+
+  set interceptors (newInterceptors) {
+    if (newInterceptors) {
+      for (let i = newInterceptors.length - 1; i >= 0; i--) {
+        const interceptor = this[kInterceptors][i]
+        if (typeof interceptor !== 'function') {
+          throw new InvalidArgumentError('interceptor must be an function')
+        }
+      }
+    }
+
+    this[kInterceptors] = newInterceptors
+  }
+
   close (callback) {
     if (callback === undefined) {
       return new Promise((resolve, reject) => {
@@ -79,8 +70,7 @@ class DispatcherBase extends Dispatcher {
     }
 
     if (this[kDestroyed]) {
-      const err = new ClientDestroyedError()
-      queueMicrotask(() => callback(err, null))
+      queueMicrotask(() => callback(new ClientDestroyedError(), null))
       return
     }
 
@@ -94,7 +84,6 @@ class DispatcherBase extends Dispatcher {
     }
 
     this[kClosed] = true
-    this[kOnClosed] ??= []
     this[kOnClosed].push(callback)
 
     const onClosed = () => {
@@ -108,7 +97,9 @@ class DispatcherBase extends Dispatcher {
     // Should not error.
     this[kClose]()
       .then(() => this.destroy())
-      .then(() => queueMicrotask(onClosed))
+      .then(() => {
+        queueMicrotask(onClosed)
+      })
   }
 
   destroy (err, callback) {
@@ -120,7 +111,7 @@ class DispatcherBase extends Dispatcher {
     if (callback === undefined) {
       return new Promise((resolve, reject) => {
         this.destroy(err, (err, data) => {
-          return err ? reject(err) : resolve(data)
+          return err ? /* istanbul ignore next: should never error */ reject(err) : resolve(data)
         })
       })
     }
@@ -143,7 +134,7 @@ class DispatcherBase extends Dispatcher {
     }
 
     this[kDestroyed] = true
-    this[kOnDestroyed] ??= []
+    this[kOnDestroyed] = this[kOnDestroyed] || []
     this[kOnDestroyed].push(callback)
 
     const onDestroyed = () => {
@@ -155,8 +146,23 @@ class DispatcherBase extends Dispatcher {
     }
 
     // Should not error.
-    this[kDestroy](err)
-      .then(() => queueMicrotask(onDestroyed))
+    this[kDestroy](err).then(() => {
+      queueMicrotask(onDestroyed)
+    })
+  }
+
+  [kInterceptedDispatch] (opts, handler) {
+    if (!this[kInterceptors] || this[kInterceptors].length === 0) {
+      this[kInterceptedDispatch] = this[kDispatch]
+      return this[kDispatch](opts, handler)
+    }
+
+    let dispatch = this[kDispatch].bind(this)
+    for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
+      dispatch = this[kInterceptors][i](dispatch)
+    }
+    this[kInterceptedDispatch] = dispatch
+    return dispatch(opts, handler)
   }
 
   dispatch (opts, handler) {
@@ -169,10 +175,6 @@ class DispatcherBase extends Dispatcher {
         throw new InvalidArgumentError('opts must be an object.')
       }
 
-      if (opts.dispatcher) {
-        throw new InvalidArgumentError('opts.dispatcher is not supported by instance methods. Pass opts.dispatcher to the top-level undici functions or call the dispatcher instance method directly.')
-      }
-
       if (this[kDestroyed] || this[kOnDestroyed]) {
         throw new ClientDestroyedError()
       }
@@ -181,13 +183,13 @@ class DispatcherBase extends Dispatcher {
         throw new ClientClosedError()
       }
 
-      return this[kDispatch](opts, handler)
+      return this[kInterceptedDispatch](opts, handler)
     } catch (err) {
-      if (typeof handler.onResponseError !== 'function') {
-        throw err
+      if (typeof handler.onError !== 'function') {
+        throw new InvalidArgumentError('invalid onError method')
       }
 
-      handler.onResponseError(null, err)
+      handler.onError(err)
 
       return false
     }

package/node_modules/undici/lib/dispatcher/dispatcher.js

@@ -1,6 +1,5 @@
 'use strict'
 const EventEmitter = require('node:events')
-const { kOriginless, kUrl } = require('../core/symbols')
 
 class Dispatcher extends EventEmitter {
   dispatch () {
@@ -18,10 +17,6 @@ class Dispatcher extends EventEmitter {
   compose (...args) {
     // So we handle [interceptor1, interceptor2] or interceptor1, interceptor2, ...
     const interceptors = Array.isArray(args[0]) ? args[0] : args
-    // null disables origin-dependent interceptors; undefined uses opts.origin.
-    const interceptorOrigin = this[kOriginless] === true
-      ? null
-      : this[kUrl]?.origin
     let dispatch = this.dispatch.bind(this)
 
     for (const interceptor of interceptors) {
@@ -33,25 +28,37 @@ class Dispatcher extends EventEmitter {
         throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`)
       }
 
-      dispatch = interceptor(dispatch, interceptorOrigin)
+      dispatch = interceptor(dispatch)
 
       if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
         throw new TypeError('invalid interceptor')
       }
     }
 
-    const originalDispatch = dispatch
-    const self = this
-    dispatch = function (opts, handler) {
-      if (opts && typeof opts === 'object' && !opts.origin && self[kUrl]) {
-        opts = Object.assign({}, opts, { origin: self[kUrl].origin })
-      }
-      return originalDispatch(opts, handler)
-    }
+    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)
+  }
 
-    return new Proxy(this, {
-      get: (target, key) => key === 'dispatch' ? dispatch : target[key]
-    })
+  destroy (...args) {
+    return this.#dispatcher.destroy(...args)
   }
 }
 

package/node_modules/undici/lib/dispatcher/env-http-proxy-agent.js

@@ -10,15 +10,24 @@ const DEFAULT_PORTS = {
   'https:': 443
 }
 
+let experimentalWarned = false
+
 class EnvHttpProxyAgent extends DispatcherBase {
   #noProxyValue = null
   #noProxyEntries = null
   #opts = null
 
   constructor (opts = {}) {
-    super(opts)
+    super()
     this.#opts = opts
 
+    if (!experimentalWarned) {
+      experimentalWarned = true
+      process.emitWarning('EnvHttpProxyAgent is experimental, expect them to change at any time.', {
+        code: 'UNDICI-EHPA'
+      })
+    }
+
     const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts
 
     this[kNoProxyAgent] = new Agent(agentOpts)
@@ -46,36 +55,32 @@ class EnvHttpProxyAgent extends DispatcherBase {
     return agent.dispatch(opts, handler)
   }
 
-  [kClose] () {
-    return Promise.all([
-      this[kNoProxyAgent].close(),
-      !this[kHttpProxyAgent][kClosed] && this[kHttpProxyAgent].close(),
-      !this[kHttpsProxyAgent][kClosed] && this[kHttpsProxyAgent].close()
-    ])
+  async [kClose] () {
+    await this[kNoProxyAgent].close()
+    if (!this[kHttpProxyAgent][kClosed]) {
+      await this[kHttpProxyAgent].close()
+    }
+    if (!this[kHttpsProxyAgent][kClosed]) {
+      await this[kHttpsProxyAgent].close()
+    }
   }
 
-  [kDestroy] (err) {
-    return Promise.all([
-      this[kNoProxyAgent].destroy(err),
-      !this[kHttpProxyAgent][kDestroyed] && this[kHttpProxyAgent].destroy(err),
-      !this[kHttpsProxyAgent][kDestroyed] && this[kHttpsProxyAgent].destroy(err)
-    ])
+  async [kDestroy] (err) {
+    await this[kNoProxyAgent].destroy(err)
+    if (!this[kHttpProxyAgent][kDestroyed]) {
+      await this[kHttpProxyAgent].destroy(err)
+    }
+    if (!this[kHttpsProxyAgent][kDestroyed]) {
+      await this[kHttpsProxyAgent].destroy(err)
+    }
   }
 
   #getProxyAgentForUrl (url) {
     let { protocol, host: hostname, port } = url
 
-    // Remove the port suffix (e.g. ":8080") and then strip surrounding
-    // brackets from IPv6 literals (e.g. "[::1]" -> "::1") so that the
-    // result matches the unbracketed form stored by #parseNoProxy.
-    hostname = hostname.replace(/:\d*$/, '').replace(/^\[(.+)\]$/, '$1').toLowerCase()
-    // Drop a trailing dot: it only marks the fully qualified form of a domain
-    // name ("example.com." and "example.com" are the same name, RFC 1034 root
-    // label). This runs on every dispatch, so it is a charCode check rather
-    // than a third regex. `length > 1` leaves the degenerate host "." alone.
-    if (hostname.length > 1 && hostname.charCodeAt(hostname.length - 1) === 46) {
-      hostname = hostname.slice(0, -1)
-    }
+    // Stripping ports in this way instead of using parsedUrl.hostname to make
+    // sure that the brackets around IPv6 addresses are kept.
+    hostname = hostname.replace(/:\d*$/, '').toLowerCase()
     port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0
     if (!this.#shouldProxy(hostname, port)) {
       return this[kNoProxyAgent]
@@ -94,31 +99,25 @@ class EnvHttpProxyAgent extends DispatcherBase {
     if (this.#noProxyEntries.length === 0) {
       return true // Always proxy if NO_PROXY is not set or empty.
     }
+    if (this.#noProxyValue === '*') {
+      return false // Never proxy if wildcard is set.
+    }
 
     for (let i = 0; i < this.#noProxyEntries.length; i++) {
       const entry = this.#noProxyEntries[i]
-      // A bare `*` entry matches all hosts regardless of its position or the
-      // surrounding whitespace (e.g. ` * ` or `none.invalid,*`). If a port is
-      // attached (`*:80`) it only bypasses that port.
-      if (entry.hostname === '*') {
-        if (entry.port && entry.port !== port) {
-          continue
-        }
-        return false // Never proxy if a wildcard entry is present.
-      }
       if (entry.port && entry.port !== port) {
         continue // Skip if ports don't match.
       }
-      // Don't proxy if the hostname is equal with the no_proxy host. A
-      // `*.example.com` wildcard matches subdomains only, not the apex
-      // `example.com`, so exact matches are skipped for wildcard entries.
-      if (!entry.wildcard && hostname === entry.hostname) {
-        return false
-      }
-      // Don't proxy if the hostname is the subdomain of the no_proxy host.
-      // Reference - https://github.com/denoland/deno/blob/6fbce91e40cc07fc6da74068e5cc56fdd40f7b4c/ext/fetch/proxy.rs#L485
-      if (hostname.slice(-(entry.hostname.length + 1)) === `.${entry.hostname}`) {
-        return false
+      if (!/^[.*]/.test(entry.hostname)) {
+        // No wildcards, so don't proxy only if there is not an exact match.
+        if (hostname === entry.hostname) {
+          return false
+        }
+      } else {
+        // Don't proxy if the hostname ends with the no_proxy host.
+        if (hostname.endsWith(entry.hostname.replace(/^\*/, ''))) {
+          return false
+        }
       }
     }
 
@@ -135,39 +134,10 @@ class EnvHttpProxyAgent extends DispatcherBase {
       if (!entry) {
         continue
       }
-
-      // An IPv6 entry with a port must be bracketed: [::1]:443.
-      // A bare IPv6 address like ::1 contains colons that must not be
-      // confused with a host:port separator, so we handle it separately.
-      let hostname, port
-      const ipv6WithPort = entry.match(/^\[(.+)\]:(\d+)$/)
-      if (ipv6WithPort) {
-        hostname = ipv6WithPort[1]
-        port = Number.parseInt(ipv6WithPort[2], 10)
-      } else {
-        // Bracketed IPv6 without port, or plain hostname[:port], or bare IPv6.
-        // Strip optional brackets first.
-        const unbracketed = entry.replace(/^\[(.+)\]$/, '$1')
-        // A bare IPv6 address contains multiple colons; a hostname:port entry
-        // has exactly one colon followed by digits. Only attempt host:port
-        // splitting when that is unambiguously the case.
-        const colonCount = (unbracketed.match(/:/g) || []).length
-        const parsed = colonCount === 1 && unbracketed.match(/^(.+):(\d+)$/)
-        hostname = parsed ? parsed[1] : unbracketed
-        port = parsed ? Number.parseInt(parsed[2], 10) : 0
-      }
-
-      // A leading `*` marks a subdomain wildcard (`*.example.com`), distinct
-      // from a plain or leading-dot suffix (`example.com` / `.example.com`)
-      // which also matches the apex. `*.example.com` must only match
-      // subdomains, never the apex `example.com` itself.
-      const wildcard = entry.charCodeAt(0) === 42 /* '*' */
-
+      const parsed = entry.match(/^(.+):(\d+)$/)
       noProxyEntries.push({
-        // strip leading dot or asterisk with dot, and any trailing dot
-        hostname: hostname.replace(/^\*?\./, '').replace(/^(.+)\.$/, '$1').toLowerCase(),
-        port,
-        wildcard
+        hostname: (parsed ? parsed[1] : entry).toLowerCase(),
+        port: parsed ? Number.parseInt(parsed[2], 10) : 0
       })
     }
 

package/node_modules/undici/lib/dispatcher/fixed-queue.js

@@ -1,10 +1,12 @@
+/* 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:
@@ -15,18 +17,18 @@ const kMask = kSize - 1
 // +-----------+ <-----\       +-----------+ <------\         +-----------+
 // |  [null]   |        \----- |   next    |         \------- |   next    |
 // +-----------+               +-----------+                  +-----------+
-// |   item    | <-- bottom    |   item    | <-- bottom       | undefined |
-// |   item    |               |   item    |                  | undefined |
-// |   item    |               |   item    |                  | undefined |
-// |   item    |               |   item    |                  | undefined |
+// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
 // |   item    |               |   item    |       bottom --> |   item    |
 // |   item    |               |   item    |                  |   item    |
 // |    ...    |               |    ...    |                  |    ...    |
 // |   item    |               |   item    |                  |   item    |
 // |   item    |               |   item    |                  |   item    |
-// | undefined | <-- top       |   item    |                  |   item    |
-// | undefined |               |   item    |                  |   item    |
-// | undefined |               | undefined | <-- top  top --> | undefined |
+// |  [empty]  | <-- top       |   item    |                  |   item    |
+// |  [empty]  |               |   item    |                  |   item    |
+// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
 // +-----------+               +-----------+                  +-----------+
 //
 // Or, if there is only one circular buffer, it looks something
@@ -38,12 +40,12 @@ const kMask = kSize - 1
 // +-----------+                               +-----------+
 // |  [null]   |                               |  [null]   |
 // +-----------+                               +-----------+
-// | undefined |                               |   item    |
-// | undefined |                               |   item    |
-// |   item    | <-- bottom            top --> | undefined |
-// |   item    |                               | undefined |
-// | undefined | <-- top            bottom --> |   item    |
-// | undefined |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |   item    | <-- bottom            top --> |  [empty]  |
+// |   item    |                               |  [empty]  |
+// |  [empty]  | <-- top            bottom --> |   item    |
+// |  [empty]  |                               |   item    |
 // +-----------+                               +-----------+
 //
 // Adding a value means moving `top` forward by one, removing means
@@ -54,82 +56,62 @@ 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 {
-  /** @type {number} */
-  bottom = 0
-  /** @type {number} */
-  top = 0
-  /** @type {Array<T|undefined>} */
-  list = new Array(kSize).fill(undefined)
-  /** @type {T|null} */
-  next = null
+  constructor() {
+    this.bottom = 0;
+    this.top = 0;
+    this.list = new Array(kSize);
+    this.next = null;
+  }
 
-  /** @returns {boolean} */
-  isEmpty () {
-    return this.top === this.bottom
+  isEmpty() {
+    return this.top === this.bottom;
   }
 
-  /** @returns {boolean} */
-  isFull () {
-    return ((this.top + 1) & kMask) === this.bottom
+  isFull() {
+    return ((this.top + 1) & kMask) === this.bottom;
   }
 
-  /**
-   * @param {T} data
-   * @returns {void}
-   */
-  push (data) {
-    this.list[this.top] = data
-    this.top = (this.top + 1) & kMask
+  push(data) {
+    this.list[this.top] = data;
+    this.top = (this.top + 1) & kMask;
   }
 
-  /** @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
+  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 () {
-    /** @type {FixedCircularBuffer<T>} */
-    this.head = this.tail = new FixedCircularBuffer()
+  constructor() {
+    this.head = this.tail = new FixedCircularBuffer();
   }
 
-  /** @returns {boolean} */
-  isEmpty () {
-    return this.head.isEmpty()
+  isEmpty() {
+    return this.head.isEmpty();
   }
 
-  /** @param {T} data */
-  push (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);
   }
 
-  /** @returns {T|null} */
-  shift () {
-    const tail = this.tail
-    const next = tail.shift()
+  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
-      tail.next = null
+      this.tail = tail.next;
     }
-    return next
+    return next;
   }
-}
+};