@libp2p/websockets 9.2.19-8484de8a2 → 9.2.19-87bc8d4fb

package/src/index.ts

@@ -25,14 +25,17 @@
 
 import { transportSymbol, serviceCapabilities, ConnectionFailedError } from '@libp2p/interface'
 import { multiaddrToUri as toUri } from '@multiformats/multiaddr-to-uri'
-import { pEvent } from 'p-event'
+import { connect } from 'it-ws/client'
+import pDefer from 'p-defer'
 import { CustomProgressEvent } from 'progress-events'
+import { raceSignal } from 'race-signal'
 import * as filters from './filters.js'
 import { createListener } from './listener.js'
-import { webSocketToMaConn } from './websocket-to-conn.js'
+import { socketToMaConn } from './socket-to-conn.js'
 import type { Transport, MultiaddrFilter, CreateListenerOptions, DialTransportOptions, Listener, AbortOptions, ComponentLogger, Logger, Connection, OutboundConnectionUpgradeEvents, Metrics, CounterGroup, Libp2pEvents } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { WebSocketOptions } from 'it-ws/client'
+import type { DuplexWebSocket } from 'it-ws/duplex'
 import type { TypedEventTarget } from 'main-event'
 import type http from 'node:http'
 import type https from 'node:https'
@@ -47,8 +50,6 @@ export interface WebSocketsInit extends AbortOptions, WebSocketOptions {
 
   /**
    * Options used to create WebSockets
-   *
-   * @deprecated This option will be removed in a future release
    */
   websocket?: ClientOptions
 
@@ -69,25 +70,6 @@ export interface WebSocketsInit extends AbortOptions, WebSocketOptions {
    * @deprecated Use the `connectionManager.inboundUpgradeTimeout` libp2p config key instead
    */
   inboundConnectionUpgradeTimeout?: number
-
-  /**
-   * How large the outgoing [bufferedAmount](https://websockets.spec.whatwg.org/#dom-websocket-bufferedamount)
-   * property of incoming and outgoing websockets is allowed to get in bytes.
-   *
-   * If this limit is exceeded, backpressure will be applied to the writer.
-   *
-   * @default 4_194_304
-   */
-  maxBufferedAmount?: number
-
-  /**
-   * If the [bufferedAmount](https://websockets.spec.whatwg.org/#dom-websocket-bufferedamount)
-   * property of a WebSocket exceeds `maxBufferedAmount`, poll the field every
-   * this number of ms to see if the socket can accept new data.
-   *
-   * @default 500
-   */
-  bufferedAmountPollInterval?: number
 }
 
 export interface WebSocketsComponents {
@@ -139,14 +121,10 @@ class WebSockets implements Transport<WebSocketsDialEvents> {
     this.log('dialing %s', ma)
     options = options ?? {}
 
-    const maConn = webSocketToMaConn({
-      websocket: await this._connect(ma, options),
-      remoteAddr: ma,
-      metrics: this.metrics?.dialerEvents,
-      direction: 'outbound',
-      log: this.components.logger.forComponent('libp2p:websockets:connection'),
-      maxBufferedAmount: this.init.maxBufferedAmount,
-      bufferedAmountPollInterval: this.init.bufferedAmountPollInterval
+    const socket = await this._connect(ma, options)
+    const maConn = socketToMaConn(socket, ma, {
+      logger: this.logger,
+      metrics: this.metrics?.dialerEvents
     })
     this.log('new outbound connection %s', maConn.remoteAddr)
 
@@ -155,35 +133,43 @@ class WebSockets implements Transport<WebSocketsDialEvents> {
     return conn
   }
 
-  async _connect (ma: Multiaddr, options: DialTransportOptions<WebSocketsDialEvents>): Promise<WebSocket> {
+  async _connect (ma: Multiaddr, options: DialTransportOptions<WebSocketsDialEvents>): Promise<DuplexWebSocket> {
     options?.signal?.throwIfAborted()
 
-    const uri = toUri(ma)
-    this.log('create websocket connection to %s', uri)
-    const websocket = new WebSocket(uri)
-    websocket.binaryType = 'arraybuffer'
+    const cOpts = ma.toOptions()
+    this.log('dialing %s:%s', cOpts.host, cOpts.port)
+
+    const errorPromise = pDefer()
+    const rawSocket = connect(toUri(ma), this.init)
+    rawSocket.socket.addEventListener('error', () => {
+      // the WebSocket.ErrorEvent type doesn't actually give us any useful
+      // information about what happened
+      // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/error_event
+      const err = new ConnectionFailedError(`Could not connect to ${ma.toString()}`)
+      this.log.error('connection error:', err)
+      this.metrics?.dialerEvents.increment({ error: true })
+      errorPromise.reject(err)
+    })
 
     try {
       options.onProgress?.(new CustomProgressEvent('websockets:open-connection'))
-      await pEvent(websocket, 'open', options)
+      await raceSignal(Promise.race([rawSocket.connected(), errorPromise.promise]), options.signal)
     } catch (err: any) {
       if (options.signal?.aborted) {
         this.metrics?.dialerEvents.increment({ abort: true })
-        throw new ConnectionFailedError(`Could not connect to ${uri}`)
-      } else {
-        this.metrics?.dialerEvents.increment({ error: true })
       }
 
-      try {
-        websocket.close()
-      } catch {}
+      rawSocket.close()
+        .catch(err => {
+          this.log.error('error closing raw socket', err)
+        })
 
       throw err
     }
 
     this.log('connected %s', ma)
     this.metrics?.dialerEvents.increment({ connect: true })
-    return websocket
+    return rawSocket
   }
 
   /**

package/src/listener.ts

@@ -1,16 +1,18 @@
 import http from 'node:http'
 import https from 'node:https'
 import net from 'node:net'
-import { getNetConfig, getThinWaistAddresses, ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils'
+import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
+import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
 import { multiaddr } from '@multiformats/multiaddr'
 import { WebSockets, WebSocketsSecure } from '@multiformats/multiaddr-matcher'
+import duplex from 'it-ws/duplex'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { pEvent } from 'p-event'
 import * as ws from 'ws'
-import { toWebSocket } from './utils.ts'
-import { webSocketToMaConn } from './websocket-to-conn.js'
+import { socketToMaConn } from './socket-to-conn.js'
 import type { ComponentLogger, Logger, Listener, ListenerEvents, CreateListenerOptions, CounterGroup, MetricGroup, Metrics, TLSCertificate, Libp2pEvents, Upgrader, MultiaddrConnection } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
+import type { DuplexWebSocket } from 'it-ws/duplex'
 import type { TypedEventTarget } from 'main-event'
 import type { EventEmitter } from 'node:events'
 import type { Server } from 'node:http'
@@ -29,8 +31,6 @@ export interface WebSocketListenerInit extends CreateListenerOptions {
   key?: string
   http?: http.ServerOptions
   https?: http.ServerOptions
-  maxBufferedAmount?: number
-  bufferedAmountPollInterval?: number
 }
 
 export interface WebSocketListenerMetrics {
@@ -40,8 +40,8 @@ export interface WebSocketListenerMetrics {
 }
 
 export class WebSocketListener extends TypedEventEmitter<ListenerEvents> implements Listener {
-  private components: WebSocketListenerComponents
   private readonly log: Logger
+  private readonly logger: ComponentLogger
   private readonly server: net.Server
   private readonly wsServer: ws.WebSocketServer
   private readonly metrics: WebSocketListenerMetrics
@@ -54,19 +54,15 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
   private https?: https.Server
   private addr?: string
   private listeningMultiaddr?: Multiaddr
-  private maxBufferedAmount?: number
-  private bufferedAmountPollInterval?: number
 
   constructor (components: WebSocketListenerComponents, init: WebSocketListenerInit) {
     super()
 
-    this.components = components
     this.log = components.logger.forComponent('libp2p:websockets:listener')
+    this.logger = components.logger
     this.upgrader = init.upgrader
     this.httpOptions = init.http
     this.httpsOptions = init.https ?? init.http
-    this.maxBufferedAmount = init.maxBufferedAmount
-    this.bufferedAmountPollInterval = init.bufferedAmountPollInterval
     this.sockets = new Set()
     this.shutdownController = new AbortController()
     setMaxListeners(Infinity, this.shutdownController.signal)
@@ -175,7 +171,6 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
 
   onWsServerConnection (socket: ws.WebSocket, req: http.IncomingMessage): void {
     let addr: string | ws.AddressInfo | null
-    socket.binaryType = 'arraybuffer'
 
     try {
       addr = this.server.address()
@@ -194,18 +189,22 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
       return
     }
 
+    const stream: DuplexWebSocket = {
+      ...duplex(socket, {
+        remoteAddress: req.socket.remoteAddress ?? '0.0.0.0',
+        remotePort: req.socket.remotePort ?? 0
+      }),
+      localAddress: addr.address,
+      localPort: addr.port
+    }
+
     let maConn: MultiaddrConnection
 
     try {
-      maConn = webSocketToMaConn({
-        websocket: toWebSocket(socket),
-        remoteAddr: toMultiaddr(req.socket.remoteAddress ?? '0.0.0.0', req.socket.remotePort ?? 0).encapsulate('/ws'),
+      maConn = socketToMaConn(stream, toMultiaddr(stream.remoteAddress ?? '', stream.remotePort ?? 0), {
+        logger: this.logger,
         metrics: this.metrics?.events,
-        metricPrefix: `${this.addr} `,
-        direction: 'inbound',
-        log: this.components.logger.forComponent('libp2p:websockets:connection'),
-        maxBufferedAmount: this.maxBufferedAmount,
-        bufferedAmountPollInterval: this.bufferedAmountPollInterval
+        metricPrefix: `${this.addr} `
       })
     } catch (err: any) {
       this.log.error('inbound connection failed', err)
@@ -223,7 +222,11 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
         this.log.error('inbound connection failed to upgrade - %e', err)
         this.metrics.errors?.increment({ [`${this.addr} inbound_upgrade`]: true })
 
-        maConn.close()
+        await maConn.close()
+          .catch(err => {
+            this.log.error('inbound connection failed to close after upgrade failed', err)
+            this.metrics.errors?.increment({ [`${this.addr} inbound_closing_failed`]: true })
+          })
       })
   }
 
@@ -246,12 +249,12 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
       this.https.addListener('tlsClientError', this.onTLSClientError.bind(this))
     }
 
-    const config = getNetConfig(ma)
-    this.addr = `${config.host}:${config.port}`
+    const options = ma.toOptions()
+    this.addr = `${options.host}:${options.port}`
 
     this.server.listen({
-      ...config,
-      ipv6Only: config.type === 'ip6'
+      ...options,
+      ipv6Only: options.family === 6
     })
 
     await new Promise<void>((resolve, reject) => {
@@ -333,7 +336,9 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
 
     await Promise.all([
       pEvent(this.server, 'close'),
+      // eslint-disable-next-line @typescript-eslint/await-thenable
       this.http == null ? null : pEvent(this.http, 'close'),
+      // eslint-disable-next-line @typescript-eslint/await-thenable
       this.https == null ? null : pEvent(this.https, 'close'),
       pEvent(this.wsServer, 'close')
     ])

package/src/socket-to-conn.ts

@@ -0,0 +1,114 @@
+import { AbortError, ConnectionFailedError } from '@libp2p/interface'
+import { CLOSE_TIMEOUT } from './constants.js'
+import type { AbortOptions, ComponentLogger, CounterGroup, MultiaddrConnection } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { DuplexWebSocket } from 'it-ws/duplex'
+
+export interface SocketToConnOptions {
+  localAddr?: Multiaddr
+  logger: ComponentLogger
+  metrics?: CounterGroup
+  metricPrefix?: string
+}
+
+// Convert a stream into a MultiaddrConnection
+// https://github.com/libp2p/interface-transport#multiaddrconnection
+export function socketToMaConn (stream: DuplexWebSocket, remoteAddr: Multiaddr, options: SocketToConnOptions): MultiaddrConnection {
+  const metrics = options.metrics
+  const metricPrefix = options.metricPrefix ?? ''
+
+  const maConn: MultiaddrConnection = {
+    log: options.logger.forComponent('libp2p:websockets:connection'),
+
+    async sink (source) {
+      try {
+        await stream.sink((async function * () {
+          for await (const buf of source) {
+            if (buf instanceof Uint8Array) {
+              yield buf
+            } else {
+              yield buf.subarray()
+            }
+          }
+        })())
+      } catch (err: any) {
+        if (err.type !== 'aborted') {
+          maConn.log.error(err)
+        }
+      }
+    },
+
+    source: stream.source,
+
+    remoteAddr,
+
+    timeline: { open: Date.now() },
+
+    async close (options: AbortOptions = {}) {
+      const start = Date.now()
+
+      if (options.signal == null) {
+        const signal = AbortSignal.timeout(CLOSE_TIMEOUT)
+
+        options = {
+          ...options,
+          signal
+        }
+      }
+
+      const listener = (): void => {
+        const { host, port } = maConn.remoteAddr.toOptions()
+        maConn.log('timeout closing stream to %s:%s after %dms, destroying it manually',
+          host, port, Date.now() - start)
+
+        this.abort(new AbortError('Socket close timeout'))
+      }
+
+      options.signal?.addEventListener('abort', listener)
+
+      try {
+        await stream.close()
+      } catch (err: any) {
+        maConn.log.error('error closing WebSocket gracefully - %e', err)
+        this.abort(err)
+      } finally {
+        options.signal?.removeEventListener('abort', listener)
+        maConn.timeline.close = Date.now()
+      }
+    },
+
+    abort (err: Error): void {
+      maConn.log.error('destroying WebSocket after error - %e', err)
+      stream.destroy()
+      maConn.timeline.close = Date.now()
+
+      // ws WebSocket.terminate does not accept an Error arg to emit an 'error'
+      // event on destroy like other node streams so we can't update a metric
+      // with an event listener
+      // https://github.com/websockets/ws/issues/1752#issuecomment-622380981
+      metrics?.increment({ [`${metricPrefix}error`]: true })
+    }
+  }
+
+  // track local vs remote closing
+  let closedLocally = false
+  const close = stream.socket.close.bind(stream.socket)
+  stream.socket.close = (...args) => {
+    closedLocally = true
+    return close(...args)
+  }
+
+  stream.socket.addEventListener('close', (evt) => {
+    maConn.log('closed %s, code %d, reason "%s", wasClean %s', closedLocally ? 'locally' : 'by remote', evt.code, evt.reason, evt.wasClean)
+
+    if (!evt.wasClean) {
+      maConn.abort(new ConnectionFailedError(`${closedLocally ? 'Local' : 'Remote'} did not close WebSocket cleanly`))
+      return
+    }
+
+    metrics?.increment({ [`${metricPrefix}close`]: true })
+    maConn.timeline.close = Date.now()
+  }, { once: true })
+
+  return maConn
+}

package/dist/src/utils.d.ts

@@ -1,7 +0,0 @@
-import type { WebSocket as WSSWebSocket } from 'ws';
-/**
- * Adds properties/methods to a `WebSocket` instance from the `ws` module to be
- * compatible with the `globalThis.WebSocket` API
- */
-export declare function toWebSocket(ws: WSSWebSocket): WebSocket;
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,IAAI,YAAY,EAAE,MAAM,IAAI,CAAA;AAEnD;;;GAGG;AACH,wBAAgB,WAAW,CAAE,EAAE,EAAE,YAAY,GAAG,SAAS,CA6BxD"}

package/dist/src/utils.js

@@ -1,30 +0,0 @@
-/**
- * Adds properties/methods to a `WebSocket` instance from the `ws` module to be
- * compatible with the `globalThis.WebSocket` API
- */
-export function toWebSocket(ws) {
-    Object.defineProperty(ws, 'url', {
-        value: '',
-        writable: false
-    });
-    // @ts-expect-error not a WS/WebSocket method
-    ws.dispatchEvent = (evt) => {
-        if (evt.type === 'close') {
-            ws.emit('close');
-        }
-        if (evt.type === 'open') {
-            ws.emit('open');
-        }
-        if (evt.type === 'message') {
-            const m = evt;
-            ws.emit('data', m.data);
-        }
-        if (evt.type === 'error') {
-            ws.emit('error', new Error('An error occurred'));
-        }
-        ws.emit(evt.type, evt);
-    };
-    // @ts-expect-error ws is now WebSocket
-    return ws;
-}
-//# sourceMappingURL=utils.js.map

package/dist/src/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAE,EAAgB;IAC3C,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,KAAK,EAAE;QAC/B,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAA;IAEF,6CAA6C;IAC7C,EAAE,CAAC,aAAa,GAAG,CAAC,GAAU,EAAE,EAAE;QAChC,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACzB,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAClB,CAAC;QAED,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACxB,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACjB,CAAC;QAED,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,CAAC,GAAG,GAAmB,CAAA;YAC7B,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAA;QACzB,CAAC;QAED,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACzB,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAA;QAClD,CAAC;QACD,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IACxB,CAAC,CAAA;IAED,uCAAuC;IACvC,OAAO,EAAE,CAAA;AACX,CAAC"}

package/dist/src/websocket-to-conn.d.ts

@@ -1,9 +0,0 @@
-import type { MultiaddrConnection } from '@libp2p/interface';
-import type { AbstractMultiaddrConnectionInit } from '@libp2p/utils';
-export interface WebSocketMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name'> {
-    websocket: WebSocket;
-    maxBufferedAmount?: number;
-    bufferedAmountPollInterval?: number;
-}
-export declare function webSocketToMaConn(init: WebSocketMultiaddrConnectionInit): MultiaddrConnection;
-//# sourceMappingURL=websocket-to-conn.d.ts.map

package/dist/src/websocket-to-conn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"websocket-to-conn.d.ts","sourceRoot":"","sources":["../../src/websocket-to-conn.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAC1E,OAAO,KAAK,EAAE,+BAA+B,EAA6B,MAAM,eAAe,CAAA;AAK/F,MAAM,WAAW,gCAAiC,SAAQ,IAAI,CAAC,+BAA+B,EAAE,MAAM,CAAC;IACrG,SAAS,EAAE,SAAS,CAAA;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,0BAA0B,CAAC,EAAE,MAAM,CAAA;CACpC;AA4FD,wBAAgB,iBAAiB,CAAE,IAAI,EAAE,gCAAgC,GAAG,mBAAmB,CAE9F"}

package/dist/src/websocket-to-conn.js

@@ -1,83 +0,0 @@
-import { AbstractMultiaddrConnection, repeatingTask } from '@libp2p/utils';
-import { Uint8ArrayList } from 'uint8arraylist';
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
-const DEFAULT_MAX_BUFFERED_AMOUNT = 1024 * 1024 * 4;
-const DEFAULT_BUFFERED_AMOUNT_POLL_INTERVAL = 10;
-class WebSocketMultiaddrConnection extends AbstractMultiaddrConnection {
-    websocket;
-    maxBufferedAmount;
-    checkBufferedAmountTask;
-    constructor(init) {
-        super(init);
-        this.websocket = init.websocket;
-        this.maxBufferedAmount = init.maxBufferedAmount ?? DEFAULT_MAX_BUFFERED_AMOUNT;
-        this.checkBufferedAmountTask = repeatingTask(this.checkBufferedAmount.bind(this), init.bufferedAmountPollInterval ?? DEFAULT_BUFFERED_AMOUNT_POLL_INTERVAL);
-        this.websocket.addEventListener('close', (evt) => {
-            this.log('closed - code %d, reason "%s", wasClean %s', evt.code, evt.reason, evt.wasClean);
-            this.checkBufferedAmountTask.stop();
-            if (!evt.wasClean) {
-                this.onRemoteReset();
-                return;
-            }
-            this.onTransportClosed();
-        }, { once: true });
-        this.websocket.addEventListener('message', (evt) => {
-            try {
-                let buf;
-                if (typeof evt.data === 'string') {
-                    buf = uint8ArrayFromString(evt.data);
-                }
-                else if (evt.data instanceof ArrayBuffer) {
-                    buf = new Uint8Array(evt.data, 0, evt.data.byteLength);
-                }
-                else {
-                    this.abort(new Error('Incorrect binary type'));
-                    return;
-                }
-                this.onData(buf);
-            }
-            catch (err) {
-                this.log.error('error receiving data - %e', err);
-            }
-        });
-    }
-    sendData(data) {
-        for (const buf of data) {
-            this.websocket.send(buf);
-        }
-        const canSendMore = this.websocket.bufferedAmount < this.maxBufferedAmount;
-        if (!canSendMore) {
-            this.checkBufferedAmountTask.start();
-        }
-        return {
-            sentBytes: data.byteLength,
-            canSendMore
-        };
-    }
-    sendReset() {
-        this.websocket.close(1006); // abnormal closure
-    }
-    async sendClose(options) {
-        this.websocket.close();
-        options?.signal?.throwIfAborted();
-    }
-    sendPause() {
-        // read backpressure is not supported
-    }
-    sendResume() {
-        // read backpressure is not supported
-    }
-    checkBufferedAmount() {
-        this.log('buffered amount now %d', this.websocket.bufferedAmount);
-        if (this.websocket.bufferedAmount === 0) {
-            this.checkBufferedAmountTask.stop();
-            this.safeDispatchEvent('drain');
-        }
-    }
-}
-// Convert a stream into a MultiaddrConnection
-// https://github.com/libp2p/interface-transport#multiaddrconnection
-export function webSocketToMaConn(init) {
-    return new WebSocketMultiaddrConnection(init);
-}
-//# sourceMappingURL=websocket-to-conn.js.map

package/dist/src/websocket-to-conn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"websocket-to-conn.js","sourceRoot":"","sources":["../../src/websocket-to-conn.ts"],"names":[],"mappings":"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"}

package/src/utils.ts

@@ -1,36 +0,0 @@
-import type { WebSocket as WSSWebSocket } from 'ws'
-
-/**
- * Adds properties/methods to a `WebSocket` instance from the `ws` module to be
- * compatible with the `globalThis.WebSocket` API
- */
-export function toWebSocket (ws: WSSWebSocket): WebSocket {
-  Object.defineProperty(ws, 'url', {
-    value: '',
-    writable: false
-  })
-
-  // @ts-expect-error not a WS/WebSocket method
-  ws.dispatchEvent = (evt: Event) => {
-    if (evt.type === 'close') {
-      ws.emit('close')
-    }
-
-    if (evt.type === 'open') {
-      ws.emit('open')
-    }
-
-    if (evt.type === 'message') {
-      const m = evt as MessageEvent
-      ws.emit('data', m.data)
-    }
-
-    if (evt.type === 'error') {
-      ws.emit('error', new Error('An error occurred'))
-    }
-    ws.emit(evt.type, evt)
-  }
-
-  // @ts-expect-error ws is now WebSocket
-  return ws
-}