@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/undici/lib/api/readable.js

@@ -1,10 +1,12 @@
+// Ported from https://github.com/nodejs/undici/pull/907
+
 'use strict'
 
 const assert = require('node:assert')
-const { addAbortListener } = require('node:events')
 const { Readable } = require('node:stream')
 const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require('../core/errors')
 const util = require('../core/util')
+const { ReadableStreamFrom } = require('../core/util')
 
 const kConsume = Symbol('kConsume')
 const kReading = Symbol('kReading')
@@ -12,25 +14,10 @@ const kBody = Symbol('kBody')
 const kAbort = Symbol('kAbort')
 const kContentType = Symbol('kContentType')
 const kContentLength = Symbol('kContentLength')
-const kUsed = Symbol('kUsed')
-const kBytesRead = Symbol('kBytesRead')
 
 const noop = () => {}
 
-/**
- * @class
- * @extends {Readable}
- * @see https://fetch.spec.whatwg.org/#body
- */
 class BodyReadable extends Readable {
-  /**
-   * @param {object} opts
-   * @param {(this: Readable, size: number) => void} opts.resume
-   * @param {() => (void | null)} opts.abort
-   * @param {string} [opts.contentType = '']
-   * @param {number} [opts.contentLength]
-   * @param {number} [opts.highWaterMark = 64 * 1024]
-   */
   constructor ({
     resume,
     abort,
@@ -47,42 +34,19 @@ class BodyReadable extends Readable {
     this._readableState.dataEmitted = false
 
     this[kAbort] = abort
-
-    /** @type {Consume | null} */
     this[kConsume] = null
-
-    /** @type {number} */
-    this[kBytesRead] = 0
-
-    /** @type {ReadableStream|null} */
     this[kBody] = null
-
-    /** @type {boolean} */
-    this[kUsed] = false
-
-    /** @type {string} */
     this[kContentType] = contentType
+    this[kContentLength] = contentLength
 
-    /** @type {number|null} */
-    this[kContentLength] = Number.isFinite(contentLength) ? contentLength : null
-
-    /**
-     * Is stream being consumed through Readable API?
-     * This is an optimization so that we avoid checking
-     * for 'data' and 'readable' listeners in the hot path
-     * inside push().
-     *
-     * @type {boolean}
-     */
+    // Is stream being consumed through Readable API?
+    // This is an optimization so that we avoid checking
+    // for 'data' and 'readable' listeners in the hot path
+    // inside push().
     this[kReading] = false
   }
 
-  /**
-   * @param {Error|null} err
-   * @param {(error:(Error|null)) => void} callback
-   * @returns {void}
-   */
-  _destroy (err, callback) {
+  destroy (err) {
     if (!err && !this._readableState.endEmitted) {
       err = new RequestAbortedError()
     }
@@ -91,47 +55,37 @@ class BodyReadable extends Readable {
       this[kAbort]()
     }
 
+    return super.destroy(err)
+  }
+
+  _destroy (err, callback) {
     // Workaround for Node "bug". If the stream is destroyed in same
     // tick as it is created, then a user who is waiting for a
-    // promise (i.e micro tick) for installing an 'error' listener will
+    // promise (i.e micro tick) for installing a 'error' listener will
     // never get a chance and will always encounter an unhandled exception.
-    if (!this[kUsed]) {
-      setImmediate(callback, err)
+    if (!this[kReading]) {
+      setImmediate(() => {
+        callback(err)
+      })
     } else {
       callback(err)
     }
   }
 
-  /**
-   * @param {string|symbol} event
-   * @param {(...args: any[]) => void} listener
-   * @returns {this}
-   */
-  on (event, listener) {
-    if (event === 'data' || event === 'readable') {
+  on (ev, ...args) {
+    if (ev === 'data' || ev === 'readable') {
       this[kReading] = true
-      this[kUsed] = true
     }
-    return super.on(event, listener)
+    return super.on(ev, ...args)
   }
 
-  /**
-   * @param {string|symbol} event
-   * @param {(...args: any[]) => void} listener
-   * @returns {this}
-   */
-  addListener (event, listener) {
-    return this.on(event, listener)
+  addListener (ev, ...args) {
+    return this.on(ev, ...args)
   }
 
-  /**
-   * @param {string|symbol} event
-   * @param {(...args: any[]) => void} listener
-   * @returns {this}
-   */
-  off (event, listener) {
-    const ret = super.off(event, listener)
-    if (event === 'data' || event === 'readable') {
+  off (ev, ...args) {
+    const ret = super.off(ev, ...args)
+    if (ev === 'data' || ev === 'readable') {
       this[kReading] = (
         this.listenerCount('data') > 0 ||
         this.listenerCount('readable') > 0
@@ -140,112 +94,58 @@ class BodyReadable extends Readable {
     return ret
   }
 
-  /**
-   * @param {string|symbol} event
-   * @param {(...args: any[]) => void} listener
-   * @returns {this}
-   */
-  removeListener (event, listener) {
-    return this.off(event, listener)
+  removeListener (ev, ...args) {
+    return this.off(ev, ...args)
   }
 
-  /**
-   * @param {Buffer|null} chunk
-   * @returns {boolean}
-   */
   push (chunk) {
-    if (chunk) {
-      this[kBytesRead] += chunk.length
-      if (this[kConsume]) {
-        consumePush(this[kConsume], chunk)
-        return this[kReading] ? super.push(chunk) : true
-      }
+    if (this[kConsume] && chunk !== null) {
+      consumePush(this[kConsume], chunk)
+      return this[kReading] ? super.push(chunk) : true
     }
-
     return super.push(chunk)
   }
 
-  /**
-   * Consumes and returns the body as a string.
-   *
-   * @see https://fetch.spec.whatwg.org/#dom-body-text
-   * @returns {Promise<string>}
-   */
-  text () {
+  // https://fetch.spec.whatwg.org/#dom-body-text
+  async text () {
     return consume(this, 'text')
   }
 
-  /**
-   * Consumes and returns the body as a JavaScript Object.
-   *
-   * @see https://fetch.spec.whatwg.org/#dom-body-json
-   * @returns {Promise<unknown>}
-   */
-  json () {
+  // https://fetch.spec.whatwg.org/#dom-body-json
+  async json () {
     return consume(this, 'json')
   }
 
-  /**
-   * Consumes and returns the body as a Blob
-   *
-   * @see https://fetch.spec.whatwg.org/#dom-body-blob
-   * @returns {Promise<Blob>}
-   */
-  blob () {
+  // https://fetch.spec.whatwg.org/#dom-body-blob
+  async blob () {
     return consume(this, 'blob')
   }
 
-  /**
-   * Consumes and returns the body as an Uint8Array.
-   *
-   * @see https://fetch.spec.whatwg.org/#dom-body-bytes
-   * @returns {Promise<Uint8Array>}
-   */
-  bytes () {
+  // https://fetch.spec.whatwg.org/#dom-body-bytes
+  async bytes () {
     return consume(this, 'bytes')
   }
 
-  /**
-   * Consumes and returns the body as an ArrayBuffer.
-   *
-   * @see https://fetch.spec.whatwg.org/#dom-body-arraybuffer
-   * @returns {Promise<ArrayBuffer>}
-   */
-  arrayBuffer () {
+  // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+  async arrayBuffer () {
     return consume(this, 'arrayBuffer')
   }
 
-  /**
-   * Not implemented
-   *
-   * @see https://fetch.spec.whatwg.org/#dom-body-formdata
-   * @throws {NotSupportedError}
-   */
+  // https://fetch.spec.whatwg.org/#dom-body-formdata
   async formData () {
     // TODO: Implement.
     throw new NotSupportedError()
   }
 
-  /**
-   * Returns true if the body is not null and the body has been consumed.
-   * Otherwise, returns false.
-   *
-   * @see https://fetch.spec.whatwg.org/#dom-body-bodyused
-   * @readonly
-   * @returns {boolean}
-   */
+  // https://fetch.spec.whatwg.org/#dom-body-bodyused
   get bodyUsed () {
     return util.isDisturbed(this)
   }
 
-  /**
-   * @see https://fetch.spec.whatwg.org/#dom-body-body
-   * @readonly
-   * @returns {ReadableStream}
-   */
+  // https://fetch.spec.whatwg.org/#dom-body-body
   get body () {
     if (!this[kBody]) {
-      this[kBody] = ReadableStream.from(this)
+      this[kBody] = ReadableStreamFrom(this)
       if (this[kConsume]) {
         // TODO: Is this the best way to force a lock?
         this[kBody].getReader() // Ensure stream is locked.
@@ -255,139 +155,63 @@ class BodyReadable extends Readable {
     return this[kBody]
   }
 
-  /**
-   * Dumps the response body by reading `limit` number of bytes.
-   * @param {object} opts
-   * @param {number} [opts.limit = 131072] Number of bytes to read.
-   * @param {AbortSignal} [opts.signal] An AbortSignal to cancel the dump.
-   * @returns {Promise<null>}
-   */
-  dump (opts) {
+  async dump (opts) {
+    let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024
     const signal = opts?.signal
 
     if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
-      return Promise.reject(new InvalidArgumentError('signal must be an AbortSignal'))
+      throw new InvalidArgumentError('signal must be an AbortSignal')
     }
 
-    const limit = opts?.limit && Number.isFinite(opts.limit)
-      ? opts.limit
-      : 128 * 1024
-
-    if (signal?.aborted) {
-      return Promise.reject(signal.reason ?? new AbortError())
-    }
+    signal?.throwIfAborted()
 
     if (this._readableState.closeEmitted) {
-      return Promise.resolve(null)
+      return null
     }
 
-    return new Promise((resolve, reject) => {
-      if (
-        (this[kContentLength] && (this[kContentLength] > limit)) ||
-        this[kBytesRead] > limit
-      ) {
+    return await new Promise((resolve, reject) => {
+      if (this[kContentLength] > limit) {
         this.destroy(new AbortError())
       }
 
-      if (signal) {
-        const onAbort = () => {
-          this.destroy(signal.reason ?? new AbortError())
-        }
-        const abortListener = addAbortListener(signal, onAbort)
-        this
-          .on('close', function () {
-            abortListener[Symbol.dispose]()
-            if (signal.aborted) {
-              reject(signal.reason ?? new AbortError())
-            } else {
-              resolve(null)
-            }
-          })
-      } else {
-        this.on('close', resolve)
+      const onAbort = () => {
+        this.destroy(signal.reason ?? new AbortError())
       }
+      signal?.addEventListener('abort', onAbort)
 
       this
+        .on('close', function () {
+          signal?.removeEventListener('abort', onAbort)
+          if (signal?.aborted) {
+            reject(signal.reason ?? new AbortError())
+          } else {
+            resolve(null)
+          }
+        })
         .on('error', noop)
-        .on('data', () => {
-          if (this[kBytesRead] > limit) {
+        .on('data', function (chunk) {
+          limit -= chunk.length
+          if (limit <= 0) {
             this.destroy()
           }
         })
         .resume()
     })
   }
-
-  /**
-   * @param {BufferEncoding} encoding
-   * @returns {this}
-   */
-  setEncoding (encoding) {
-    if (Buffer.isEncoding(encoding)) {
-      // Delegate to Node.js Readable.setEncoding() which initializes a
-      // StringDecoder and re-encodes already-buffered chunks. This properly
-      // handles multi-byte sequences split at chunk boundaries for the
-      // for-await / on('data') paths. Without this, Node.js uses
-      // buf.toString(encoding) on each chunk, producing U+FFFD for split chars.
-      //
-      // The consume path (body.text(), body.json(), ...) copes with the
-      // decoded strings this leaves in state.buffer, see consumeStart().
-      super.setEncoding(encoding)
-    }
-    return this
-  }
 }
 
-/**
- * @see https://streams.spec.whatwg.org/#readablestream-locked
- * @param {BodyReadable} bodyReadable
- * @returns {boolean}
- */
-function isLocked (bodyReadable) {
+// https://streams.spec.whatwg.org/#readablestream-locked
+function isLocked (self) {
   // Consume is an implicit lock.
-  return bodyReadable[kBody]?.locked === true || bodyReadable[kConsume] !== null
+  return (self[kBody] && self[kBody].locked === true) || self[kConsume]
 }
 
-/**
- * @see https://fetch.spec.whatwg.org/#body-unusable
- * @param {BodyReadable} bodyReadable
- * @returns {boolean}
- */
-function isUnusable (bodyReadable) {
-  return util.isDisturbed(bodyReadable) || isLocked(bodyReadable)
+// https://fetch.spec.whatwg.org/#body-unusable
+function isUnusable (self) {
+  return util.isDisturbed(self) || isLocked(self)
 }
 
-/**
- * @typedef {'text' | 'json' | 'blob' | 'bytes' | 'arrayBuffer'} ConsumeType
- */
-
-/**
- * @template {ConsumeType} T
- * @typedef {T extends 'text' ? string :
- *           T extends 'json' ? unknown :
- *           T extends 'blob' ? Blob :
- *           T extends 'arrayBuffer' ? ArrayBuffer :
- *           T extends 'bytes' ? Uint8Array :
- *           never
- * } ConsumeReturnType
- */
-/**
- * @typedef {object} Consume
- * @property {ConsumeType} type
- * @property {BodyReadable} stream
- * @property {((value?: any) => void)} resolve
- * @property {((err: Error) => void)} reject
- * @property {number} length
- * @property {Buffer[]} body
- */
-
-/**
- * @template {ConsumeType} T
- * @param {BodyReadable} stream
- * @param {T} type
- * @returns {Promise<ConsumeReturnType<T>>}
- */
-function consume (stream, type) {
+async function consume (stream, type) {
   assert(!stream[kConsume])
 
   return new Promise((resolve, reject) => {
@@ -395,7 +219,9 @@ function consume (stream, type) {
       const rState = stream._readableState
       if (rState.destroyed && rState.closeEmitted === false) {
         stream
-          .on('error', reject)
+          .on('error', err => {
+            reject(err)
+          })
           .on('close', () => {
             reject(new TypeError('unusable'))
           })
@@ -429,10 +255,6 @@ function consume (stream, type) {
   })
 }
 
-/**
- * @param {Consume} consume
- * @returns {void}
- */
 function consumeStart (consume) {
   if (consume.body === null) {
     return
@@ -452,29 +274,14 @@ function consumeStart (consume) {
     }
   }
 
-  // If setEncoding() was called, state.buffer holds decoded strings, which
-  // consumePush() turns back into bytes. The trailing bytes of a multi-byte
-  // sequence split across a chunk boundary are not part of any of those
-  // strings, they are held inside the decoder until the rest arrives, so
-  // take them from there.
-  const decoder = state.decoder
-  if (decoder != null && decoder.lastNeed > 0) {
-    consumePush(consume, Buffer.from(decoder.lastChar.subarray(0, decoder.lastTotal - decoder.lastNeed)))
-  }
-
   if (state.endEmitted) {
-    // No `this` to read the consume off here: consumeStart is a free function, called from
-    // the queueMicrotask above. The callback below does have one, because the emitter passes
-    // the stream as its receiver. Returning matters too - consumeEnd() clears consume.stream,
-    // which the resume() below would then dereference.
-    consumeEnd(consume, state.encoding)
-    return
+    consumeEnd(this[kConsume])
+  } else {
+    consume.stream.on('end', function () {
+      consumeEnd(this[kConsume])
+    })
   }
 
-  consume.stream.on('end', function () {
-    consumeEnd(this[kConsume], this._readableState.encoding)
-  })
-
   consume.stream.resume()
 
   while (consume.stream.read() != null) {
@@ -485,10 +292,8 @@ function consumeStart (consume) {
 /**
  * @param {Buffer[]} chunks
  * @param {number} length
- * @param {BufferEncoding} [encoding='utf8']
- * @returns {string}
  */
-function chunksDecode (chunks, length, encoding) {
+function chunksDecode (chunks, length) {
   if (chunks.length === 0 || length === 0) {
     return ''
   }
@@ -503,11 +308,7 @@ function chunksDecode (chunks, length, encoding) {
     buffer[2] === 0xbf
       ? 3
       : 0
-  if (!encoding || encoding === 'utf8' || encoding === 'utf-8') {
-    return buffer.utf8Slice(start, bufferLength)
-  } else {
-    return buffer.subarray(start, bufferLength).toString(encoding)
-  }
+  return buffer.utf8Slice(start, bufferLength)
 }
 
 /**
@@ -535,19 +336,14 @@ function chunksConcat (chunks, length) {
   return buffer
 }
 
-/**
- * @param {Consume} consume
- * @param {BufferEncoding} encoding
- * @returns {void}
- */
-function consumeEnd (consume, encoding) {
+function consumeEnd (consume) {
   const { type, body, resolve, stream, length } = consume
 
   try {
     if (type === 'text') {
-      resolve(chunksDecode(body, length, encoding))
+      resolve(chunksDecode(body, length))
     } else if (type === 'json') {
-      resolve(JSON.parse(chunksDecode(body, length, encoding)))
+      resolve(JSON.parse(chunksDecode(body, length)))
     } else if (type === 'arrayBuffer') {
       resolve(chunksConcat(body, length).buffer)
     } else if (type === 'blob') {
@@ -562,33 +358,11 @@ function consumeEnd (consume, encoding) {
   }
 }
 
-/**
- * @param {Consume} consume
- * @param {Buffer|string} chunk
- * @returns {void}
- */
 function consumePush (consume, chunk) {
-  if (consume.body === null) {
-    return
-  }
-
-  if (typeof chunk === 'string') {
-    // Buffered before the consume started, while an encoding was set.
-    // consume.length has to stay a byte count and chunksDecode()/chunksConcat()
-    // only work on bytes, so re-encode. A string's own length is in UTF-16 code
-    // units and Uint8Array.prototype.set() ignores a string argument entirely.
-    chunk = Buffer.from(chunk, consume.stream._readableState.encoding)
-  }
-
   consume.length += chunk.length
   consume.body.push(chunk)
 }
 
-/**
- * @param {Consume} consume
- * @param {Error} [err]
- * @returns {void}
- */
 function consumeFinish (consume, err) {
   if (consume.body === null) {
     return
@@ -600,7 +374,6 @@ function consumeFinish (consume, err) {
     consume.resolve()
   }
 
-  // Reset the consume object to allow for garbage collection.
   consume.type = null
   consume.stream = null
   consume.resolve = null
@@ -609,7 +382,4 @@ function consumeFinish (consume, err) {
   consume.body = null
 }
 
-module.exports = {
-  Readable: BodyReadable,
-  chunksDecode
-}
+module.exports = { Readable: BodyReadable, chunksDecode }

package/node_modules/undici/lib/api/util.js

@@ -0,0 +1,93 @@
+const assert = require('node:assert')
+const {
+  ResponseStatusCodeError
+} = require('../core/errors')
+
+const { chunksDecode } = require('./readable')
+const CHUNK_LIMIT = 128 * 1024
+
+async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) {
+  assert(body)
+
+  let chunks = []
+  let length = 0
+
+  try {
+    for await (const chunk of body) {
+      chunks.push(chunk)
+      length += chunk.length
+      if (length > CHUNK_LIMIT) {
+        chunks = []
+        length = 0
+        break
+      }
+    }
+  } catch {
+    chunks = []
+    length = 0
+    // Do nothing....
+  }
+
+  const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`
+
+  if (statusCode === 204 || !contentType || !length) {
+    queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers)))
+    return
+  }
+
+  const stackTraceLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  let payload
+
+  try {
+    if (isContentTypeApplicationJson(contentType)) {
+      payload = JSON.parse(chunksDecode(chunks, length))
+    } else if (isContentTypeText(contentType)) {
+      payload = chunksDecode(chunks, length)
+    }
+  } catch {
+    // process in a callback to avoid throwing in the microtask queue
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit
+  }
+  queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload)))
+}
+
+const isContentTypeApplicationJson = (contentType) => {
+  return (
+    contentType.length > 15 &&
+    contentType[11] === '/' &&
+    contentType[0] === 'a' &&
+    contentType[1] === 'p' &&
+    contentType[2] === 'p' &&
+    contentType[3] === 'l' &&
+    contentType[4] === 'i' &&
+    contentType[5] === 'c' &&
+    contentType[6] === 'a' &&
+    contentType[7] === 't' &&
+    contentType[8] === 'i' &&
+    contentType[9] === 'o' &&
+    contentType[10] === 'n' &&
+    contentType[12] === 'j' &&
+    contentType[13] === 's' &&
+    contentType[14] === 'o' &&
+    contentType[15] === 'n'
+  )
+}
+
+const isContentTypeText = (contentType) => {
+  return (
+    contentType.length > 4 &&
+    contentType[4] === '/' &&
+    contentType[0] === 't' &&
+    contentType[1] === 'e' &&
+    contentType[2] === 'x' &&
+    contentType[3] === 't'
+  )
+}
+
+module.exports = {
+  getResolveErrorBodyCallback,
+  isContentTypeApplicationJson,
+  isContentTypeText
+}