@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/undici/lib/web/websocket/sender.js

@@ -4,6 +4,9 @@ const { WebsocketFrameSend } = require('./frame')
 const { opcodes, sendHints } = require('./constants')
 const FixedQueue = require('../../dispatcher/fixed-queue')
 
+/** @type {typeof Uint8Array} */
+const FastBuffer = Buffer[Symbol.species]
+
 /**
  * @typedef {object} SendQueueNode
  * @property {Promise<void> | null} promise
@@ -31,25 +34,16 @@ class SendQueue {
 
   add (item, cb, hint) {
     if (hint !== sendHints.blob) {
+      const frame = createFrame(item, hint)
       if (!this.#running) {
-        // TODO(@tsctx): support fast-path for string on running
-        if (hint === sendHints.text) {
-          // special fast-path for string
-          const { 0: head, 1: body } = WebsocketFrameSend.createFastTextFrame(item)
-          this.#socket.cork()
-          this.#socket.write(head)
-          this.#socket.write(body, cb)
-          this.#socket.uncork()
-        } else {
-          // direct writing
-          this.#socket.write(createFrame(item, hint), cb)
-        }
+        // fast-path
+        this.#socket.write(frame, cb)
       } else {
         /** @type {SendQueueNode} */
         const node = {
           promise: null,
           callback: cb,
-          frame: createFrame(item, hint)
+          frame
         }
         this.#queue.push(node)
       }
@@ -92,17 +86,18 @@ class SendQueue {
 }
 
 function createFrame (data, hint) {
-  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.text ? opcodes.TEXT : opcodes.BINARY)
+  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY)
 }
 
 function toBuffer (data, hint) {
   switch (hint) {
-    case sendHints.text:
-    case sendHints.typedArray:
-      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+    case sendHints.string:
+      return Buffer.from(data)
     case sendHints.arrayBuffer:
     case sendHints.blob:
-      return new Uint8Array(data)
+      return new FastBuffer(data)
+    case sendHints.typedArray:
+      return new FastBuffer(data.buffer, data.byteOffset, data.byteLength)
   }
 }
 

package/node_modules/undici/lib/web/websocket/symbols.js

@@ -0,0 +1,12 @@
+'use strict'
+
+module.exports = {
+  kWebSocketURL: Symbol('url'),
+  kReadyState: Symbol('ready state'),
+  kController: Symbol('controller'),
+  kResponse: Symbol('response'),
+  kBinaryType: Symbol('binary type'),
+  kSentClose: Symbol('sent close'),
+  kReceivedClose: Symbol('received close'),
+  kByteParser: Symbol('byte parser')
+}

package/node_modules/undici/lib/web/websocket/util.js

@@ -1,48 +1,51 @@
 'use strict'
 
+const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require('./symbols')
 const { states, opcodes } = require('./constants')
+const { ErrorEvent, createFastMessageEvent } = require('./events')
 const { isUtf8 } = require('node:buffer')
-const { removeHTTPWhitespace } = require('../fetch/data-url')
-const { collectASequenceOfCodePointsFast } = require('../infra')
+const { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = require('../fetch/data-url')
+
+/* globals Blob */
 
 /**
- * @param {number} readyState
+ * @param {import('./websocket').WebSocket} ws
  * @returns {boolean}
  */
-function isConnecting (readyState) {
+function isConnecting (ws) {
   // If the WebSocket connection is not yet established, and the connection
   // is not yet closed, then the WebSocket connection is in the CONNECTING state.
-  return readyState === states.CONNECTING
+  return ws[kReadyState] === states.CONNECTING
 }
 
 /**
- * @param {number} readyState
+ * @param {import('./websocket').WebSocket} ws
  * @returns {boolean}
  */
-function isEstablished (readyState) {
+function isEstablished (ws) {
   // If the server's response is validated as provided for above, it is
   // said that _The WebSocket Connection is Established_ and that the
   // WebSocket Connection is in the OPEN state.
-  return readyState === states.OPEN
+  return ws[kReadyState] === states.OPEN
 }
 
 /**
- * @param {number} readyState
+ * @param {import('./websocket').WebSocket} ws
  * @returns {boolean}
  */
-function isClosing (readyState) {
+function isClosing (ws) {
   // Upon either sending or receiving a Close control frame, it is said
   // that _The WebSocket Closing Handshake is Started_ and that the
   // WebSocket connection is in the CLOSING state.
-  return readyState === states.CLOSING
+  return ws[kReadyState] === states.CLOSING
 }
 
 /**
- * @param {number} readyState
+ * @param {import('./websocket').WebSocket} ws
  * @returns {boolean}
  */
-function isClosed (readyState) {
-  return readyState === states.CLOSED
+function isClosed (ws) {
+  return ws[kReadyState] === states.CLOSED
 }
 
 /**
@@ -51,7 +54,6 @@ function isClosed (readyState) {
  * @param {EventTarget} target
  * @param {(...args: ConstructorParameters<typeof Event>) => Event} eventFactory
  * @param {EventInit | undefined} eventInitDict
- * @returns {void}
  */
 function fireEvent (e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
   // 1. If eventConstructor is not given, then let eventConstructor be Event.
@@ -71,24 +73,56 @@ function fireEvent (e, target, eventFactory = (type, init) => new Event(type, in
 
 /**
  * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
- * @param {import('./websocket').Handler} handler
+ * @param {import('./websocket').WebSocket} ws
  * @param {number} type Opcode
  * @param {Buffer} data application data
- * @returns {void}
  */
-function websocketMessageReceived (handler, type, data) {
-  handler.onMessage(type, data)
+function websocketMessageReceived (ws, type, data) {
+  // 1. If ready state is not OPEN (1), then return.
+  if (ws[kReadyState] !== states.OPEN) {
+    return
+  }
+
+  // 2. Let dataForEvent be determined by switching on type and binary type:
+  let dataForEvent
+
+  if (type === opcodes.TEXT) {
+    // -> type indicates that the data is Text
+    //      a new DOMString containing data
+    try {
+      dataForEvent = utf8Decode(data)
+    } catch {
+      failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.')
+      return
+    }
+  } else if (type === opcodes.BINARY) {
+    if (ws[kBinaryType] === 'blob') {
+      // -> type indicates that the data is Binary and binary type is "blob"
+      //      a new Blob object, created in the relevant Realm of the WebSocket
+      //      object, that represents data as its raw data
+      dataForEvent = new Blob([data])
+    } else {
+      // -> type indicates that the data is Binary and binary type is "arraybuffer"
+      //      a new ArrayBuffer object, created in the relevant Realm of the
+      //      WebSocket object, whose contents are data
+      dataForEvent = toArrayBuffer(data)
+    }
+  }
+
+  // 3. Fire an event named message at the WebSocket object, using MessageEvent,
+  //    with the origin attribute initialized to the serialization of the WebSocket
+  //    object’s url's origin, and the data attribute initialized to dataForEvent.
+  fireEvent('message', ws, createFastMessageEvent, {
+    origin: ws[kWebSocketURL].origin,
+    data: dataForEvent
+  })
 }
 
-/**
- * @param {Buffer} buffer
- * @returns {ArrayBuffer}
- */
 function toArrayBuffer (buffer) {
   if (buffer.byteLength === buffer.buffer.byteLength) {
     return buffer.buffer
   }
-  return new Uint8Array(buffer).buffer
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
 }
 
 /**
@@ -96,7 +130,6 @@ function toArrayBuffer (buffer) {
  * @see https://datatracker.ietf.org/doc/html/rfc2616
  * @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407
  * @param {string} protocol
- * @returns {boolean}
  */
 function isValidSubprotocol (protocol) {
   // If present, this value indicates one
@@ -143,7 +176,6 @@ function isValidSubprotocol (protocol) {
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4
  * @param {number} code
- * @returns {boolean}
  */
 function isValidStatusCode (code) {
   if (code >= 1000 && code < 1015) {
@@ -157,10 +189,31 @@ function isValidStatusCode (code) {
   return code >= 3000 && code <= 4999
 }
 
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @param {string|undefined} reason
+ */
+function failWebsocketConnection (ws, reason) {
+  const { [kController]: controller, [kResponse]: response } = ws
+
+  controller.abort()
+
+  if (response?.socket && !response.socket.destroyed) {
+    response.socket.destroy()
+  }
+
+  if (reason) {
+    // TODO: process.nextTick
+    fireEvent('error', ws, (type, init) => new ErrorEvent(type, init), {
+      error: new Error(reason),
+      message: reason
+    })
+  }
+}
+
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.5
  * @param {number} opcode
- * @returns {boolean}
  */
 function isControlFrame (opcode) {
   return (
@@ -170,27 +223,14 @@ function isControlFrame (opcode) {
   )
 }
 
-/**
- * @param {number} opcode
- * @returns {boolean}
- */
 function isContinuationFrame (opcode) {
   return opcode === opcodes.CONTINUATION
 }
 
-/**
- * @param {number} opcode
- * @returns {boolean}
- */
 function isTextBinaryFrame (opcode) {
   return opcode === opcodes.TEXT || opcode === opcodes.BINARY
 }
 
-/**
- *
- * @param {number} opcode
- * @returns {boolean}
- */
 function isValidOpcode (opcode) {
   return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode)
 }
@@ -207,7 +247,7 @@ function parseExtensions (extensions) {
 
   while (position.position < extensions.length) {
     const pair = collectASequenceOfCodePointsFast(';', extensions, position)
-    const [name, value = ''] = pair.split('=', 2)
+    const [name, value = ''] = pair.split('=')
 
     extensionList.set(
       removeHTTPWhitespace(name, true, false),
@@ -224,7 +264,6 @@ function parseExtensions (extensions) {
  * @see https://www.rfc-editor.org/rfc/rfc7692#section-7.1.2.2
  * @description "client-max-window-bits = 1*DIGIT"
  * @param {string} value
- * @returns {boolean}
  */
 function isValidClientWindowBits (value) {
   // Must have at least one character
@@ -246,84 +285,22 @@ function isValidClientWindowBits (value) {
   return num >= 8 && num <= 15
 }
 
-/**
- * @see https://whatpr.org/websockets/48/7b748d3...d5570f3.html#get-a-url-record
- * @param {string} url
- * @param {string} [baseURL]
- */
-function getURLRecord (url, baseURL) {
-  // 1. Let urlRecord be the result of applying the URL parser to url with baseURL .
-  // 2. If urlRecord is failure, then throw a " SyntaxError " DOMException .
-  let urlRecord
-
-  try {
-    urlRecord = new URL(url, baseURL)
-  } catch (e) {
-    throw new DOMException(e, 'SyntaxError')
-  }
-
-  // 3. If urlRecord ’s scheme is " http ", then set urlRecord ’s scheme to " ws ".
-  // 4. Otherwise, if urlRecord ’s scheme is " https ", set urlRecord ’s scheme to " wss ".
-  if (urlRecord.protocol === 'http:') {
-    urlRecord.protocol = 'ws:'
-  } else if (urlRecord.protocol === 'https:') {
-    urlRecord.protocol = 'wss:'
-  }
-
-  // 5. If urlRecord ’s scheme is not " ws " or " wss ", then throw a " SyntaxError " DOMException .
-  if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
-    throw new DOMException('expected a ws: or wss: url', 'SyntaxError')
-  }
-
-  // If urlRecord ’s fragment is non-null, then throw a " SyntaxError " DOMException .
-  if (urlRecord.hash.length || urlRecord.href.endsWith('#')) {
-    throw new DOMException('hash', 'SyntaxError')
-  }
-
-  // Return urlRecord .
-  return urlRecord
-}
-
-// https://whatpr.org/websockets/48.html#validate-close-code-and-reason
-function validateCloseCodeAndReason (code, reason) {
-  // 1. If code is not null, but is neither an integer equal to
-  //    1000 nor an integer in the range 3000 to 4999, inclusive,
-  //    throw an "InvalidAccessError" DOMException.
-  if (code !== null) {
-    if (code !== 1000 && (code < 3000 || code > 4999)) {
-      throw new DOMException('invalid code', 'InvalidAccessError')
-    }
-  }
-
-  // 2. If reason is not null, then:
-  if (reason !== null) {
-    // 2.1. Let reasonBytes be the result of UTF-8 encoding reason.
-    // 2.2. If reasonBytes is longer than 123 bytes, then throw a
-    //      "SyntaxError" DOMException.
-    const reasonBytesLength = Buffer.byteLength(reason)
-
-    if (reasonBytesLength > 123) {
-      throw new DOMException(`Reason must be less than 123 bytes; received ${reasonBytesLength}`, 'SyntaxError')
-    }
-  }
-}
+// https://nodejs.org/api/intl.html#detecting-internationalization-support
+const hasIntl = typeof process.versions.icu === 'string'
+const fatalDecoder = hasIntl ? new TextDecoder('utf-8', { fatal: true }) : undefined
 
 /**
  * Converts a Buffer to utf-8, even on platforms without icu.
- * @type {(buffer: Buffer) => string}
+ * @param {Buffer} buffer
  */
-const utf8Decode = (() => {
-  if (typeof process.versions.icu === 'string') {
-    const fatalDecoder = new TextDecoder('utf-8', { fatal: true })
-    return fatalDecoder.decode.bind(fatalDecoder)
-  }
-  return function (buffer) {
+const utf8Decode = hasIntl
+  ? fatalDecoder.decode.bind(fatalDecoder)
+  : function (buffer) {
     if (isUtf8(buffer)) {
       return buffer.toString('utf-8')
     }
     throw new TypeError('Invalid utf-8 received.')
   }
-})()
 
 module.exports = {
   isConnecting,
@@ -333,6 +310,7 @@ module.exports = {
   fireEvent,
   isValidSubprotocol,
   isValidStatusCode,
+  failWebsocketConnection,
   websocketMessageReceived,
   utf8Decode,
   isControlFrame,
@@ -340,8 +318,5 @@ module.exports = {
   isTextBinaryFrame,
   isValidOpcode,
   parseExtensions,
-  isValidClientWindowBits,
-  toArrayBuffer,
-  getURLRecord,
-  validateCloseCodeAndReason
+  isValidClientWindowBits
 }