extra-native-websocket 0.3.1 → 0.3.2

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "extra-native-websocket",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "",
   "keywords": [],
   "files": [
     "lib",
-    "dist"
+    "src"
   ],
   "main": "lib/es2018/index.js",
   "types": "lib/es2018/index.d.ts",

package/src/extra-native-websocket.ts

@@ -0,0 +1,137 @@
+import { assert } from '@blackglory/prelude'
+import { WebSocketError } from './websocket-error'
+import { Queue, Emitter } from '@blackglory/structures'
+
+export enum BinaryType {
+  Blob
+, ArrayBuffer
+}
+
+export enum State {
+  Closed
+, Connecting
+, Connected
+, Closing
+}
+
+enum ReadyState {
+  CONNECTING = 0
+, OPEN = 1
+, CLOSING = 2
+, CLOSED = 3
+}
+
+export class ExtraNativeWebSocket extends Emitter<{
+  open: [event: Event]
+  message: [event: MessageEvent]
+  error: [event: Event]
+  close: [event: CloseEvent]
+}> {
+  private instance?: WebSocket
+  private binaryType: BinaryType = BinaryType.Blob
+  protected unsentMessages = new Queue<string | ArrayBufferLike | Blob | ArrayBufferView>()
+
+  constructor(private createWebSocket: () => WebSocket) {
+    super()
+  }
+
+  getState(): State {
+    if (this.instance) {
+      switch (this.instance.readyState) {
+        case ReadyState.CONNECTING: return State.Connecting
+        case ReadyState.OPEN: return State.Connected
+        case ReadyState.CLOSING: return State.Closing
+        case ReadyState.CLOSED: return State.Closed
+        default: throw new Error('Unknown state')
+      }
+    } else {
+      return State.Closed
+    }
+  }
+
+  getBinaryType(): BinaryType {
+    return this.binaryType
+  }
+
+  setBinaryType(val: BinaryType): void {
+    this.binaryType = val
+
+    if (this.instance) {
+      switch (val) {
+        case BinaryType.Blob:
+          this.instance.binaryType = 'blob'
+          break
+        case BinaryType.ArrayBuffer:
+          this.instance.binaryType = 'arraybuffer'
+          break
+        default: throw new Error('Unknown binary type')
+      }
+    }
+  }
+
+  /**
+   * @throws {WebSocketError}
+   */
+  connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      assert(this.getState() === State.Closed, 'WebSocket is not closed')
+
+      const self = this
+      const ws = this.instance = this.createWebSocket()
+
+      ws.addEventListener('error', errorListener, { once: true })
+
+      ws.addEventListener('open', event => this.emit('open', event))
+      ws.addEventListener('message', event => this.emit('message', event))
+      ws.addEventListener('error', event => this.emit('error', event))
+      ws.addEventListener('close', event => this.emit('close', event))
+
+      this.setBinaryType(this.binaryType)
+
+      ws.addEventListener('open', openListener, { once: true })
+
+      function errorListener(event: Event): void {
+        ws.addEventListener('close', closeListener, { once: true })
+      }
+
+      function closeListener(event: CloseEvent): void {
+        reject(new WebSocketError(event.code, event.reason))
+      }
+
+      function openListener(event: Event): void {
+        ws.removeEventListener('error', errorListener)
+        ws.removeEventListener('close', closeListener)
+        for (let size = self.unsentMessages.size; size--;) {
+          self.send(self.unsentMessages.dequeue()!)
+        }
+        resolve()
+      }
+    })
+  }
+
+  close(code?: number, reason?: string): Promise<void> {
+    return new Promise<void>(resolve => {
+      assert(this.instance, 'WebSocket is not created')
+
+      switch (this.getState()) {
+        case State.Closed:
+          resolve()
+          break
+        case State.Closing:
+          this.instance.addEventListener('close', () => resolve(), { once: true })
+          break
+        default:
+          this.instance.addEventListener('close', () => resolve(), { once: true })
+          this.instance.close(code, reason)
+      }
+    })
+  }
+
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {
+    if (this.getState() === State.Connected) {
+      this.instance!.send(data)
+    } else {
+      this.unsentMessages.enqueue(data)
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './extra-native-websocket'
+export * from './websocket-error'
+export * from './utils'

package/src/utils/auto-reconnect-with-exponential-back-off.ts

@@ -0,0 +1,60 @@
+import { ExtraNativeWebSocket, State } from '@src/extra-native-websocket'
+import { calculateExponentialBackoffTimeout } from 'extra-timers'
+import { pass } from '@blackglory/prelude'
+import { delay } from 'extra-promise'
+import { waitForFunction } from '@blackglory/wait-for'
+
+export function autoReconnectWithExponentialBackOff(
+  ws: ExtraNativeWebSocket
+, {
+    baseTimeout
+  , maxTimeout = Infinity
+  , factor = 2
+  , jitter = true
+  }: {
+    baseTimeout: number
+    maxTimeout?: number
+    factor?: number
+    jitter?: boolean
+  }
+): () => void {
+  const controller = new AbortController()
+
+  // Make sure the error listener is added, prevent crashes due to uncaught errors.
+  const removeErrorListener = ws.on('error', pass)
+  let removeCloseListener = ws.once('close', closeListener)
+
+  return () => {
+    controller.abort()
+    removeCloseListener()
+    removeErrorListener()
+  }
+
+  async function closeListener(): Promise<void> {
+    let retries = 0
+    while (true) {
+      if (controller.signal.aborted) return
+
+      await delay(calculateExponentialBackoffTimeout({
+        retries
+      , baseTimeout
+      , maxTimeout
+      , factor
+      , jitter
+      }))
+      if (controller.signal.aborted) return
+
+      try {
+        await waitForFunction(() => ws.getState() === State.Closed)
+        await ws.connect()
+        if (controller.signal.aborted) return
+
+        removeCloseListener = ws.once('close', closeListener)
+        break
+      } catch {
+        retries++
+        pass()
+      }
+    }
+  }
+}

package/src/utils/auto-reconnect.ts

@@ -0,0 +1,36 @@
+import { ExtraNativeWebSocket, State } from '@src/extra-native-websocket'
+import { delay } from 'extra-promise'
+import { AbortController } from 'extra-abort'
+import { pass } from '@blackglory/prelude'
+import { waitForFunction } from '@blackglory/wait-for'
+
+export function autoReconnect(ws: ExtraNativeWebSocket, timeout: number = 0): () => void {
+  const controller = new AbortController()
+
+  let removeCloseListener = ws.once('close', closeListener)
+
+  return () => {
+    controller.abort()
+    removeCloseListener()
+  }
+
+  async function closeListener(): Promise<void> {
+    while (true) {
+      if (controller.signal.aborted) return
+
+      await delay(timeout)
+      if (controller.signal.aborted) return
+
+      try {
+        await waitForFunction(() => ws.getState() === State.Closed)
+        await ws.connect()
+        if (controller.signal.aborted) return
+
+        removeCloseListener = ws.once('close', closeListener)
+        break
+      } catch {
+        pass()
+      }
+    }
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './auto-reconnect'
+export * from './auto-reconnect-with-exponential-back-off'

package/src/websocket-error.ts

@@ -0,0 +1,17 @@
+import { CustomError } from '@blackglory/errors'
+
+export class WebSocketError extends CustomError {
+  readonly code: number
+  readonly reason: string
+
+  constructor(code: number, reason: string) {
+    if (reason) {
+      super(`${code}: ${reason}`)
+    } else {
+      super(`${code}`)
+    }
+
+    this.code = code
+    this.reason = reason
+  }
+}