async-lube 2.0.0 → 2.1.0

package/src/http/socket.js

@@ -44,15 +44,21 @@ function check_socket_options(options) {
 		"ws"
 	)
 	const { as, heartbeat, limit, outbox } = options
-	if (as != null && as != "json" && as != "text") throw TypeError(
-		"The as of ws() must be \"json\" or \"text\""
-	)
-	if (limit != null && !(limit === Infinity || Number.isInteger(limit) && limit >= 1)) throw TypeError(
-		"The limit of ws() must be a positive integer or Infinity"
-	)
-	if (outbox != null && !(outbox === Infinity || Number.isInteger(outbox) && outbox >= 0)) throw TypeError(
-		"The outbox of ws() must be a non-negative integer or Infinity"
-	)
+	if (as != null && as != "json" && as != "text") {
+		throw TypeError(
+			"The as of ws() must be \"json\" or \"text\""
+		)
+	}
+	if (limit != null && !(limit === Infinity || Number.isInteger(limit) && limit >= 1)) {
+		throw TypeError(
+			"The limit of ws() must be a positive integer or Infinity"
+		)
+	}
+	if (outbox != null && !(outbox === Infinity || Number.isInteger(outbox) && outbox >= 0)) {
+		throw TypeError(
+			"The outbox of ws() must be a non-negative integer or Infinity"
+		)
+	}
 	if (heartbeat != null) {
 		check_options(
 			heartbeat,
@@ -60,9 +66,11 @@ function check_socket_options(options) {
 			"ws",
 			"heartbeat."
 		)
-		if (!(typeof heartbeat.interval == "number" && heartbeat.interval > 0)) throw TypeError(
-			"The heartbeat interval of ws() must be positive milliseconds"
-		)
+		if (!(typeof heartbeat.interval == "number" && heartbeat.interval > 0)) {
+			throw TypeError(
+				"The heartbeat interval of ws() must be positive milliseconds"
+			)
+		}
 	}
 	check_reconnect(options.reconnect, "ws")
 }
@@ -72,9 +80,9 @@ function check_socket_options(options) {
  */
 function is_raw_message(data) {
 	return typeof data == "string"
-	|| data instanceof ArrayBuffer
-	|| ArrayBuffer.isView(data)
-	|| typeof Blob != "undefined" && data instanceof Blob
+		|| data instanceof ArrayBuffer
+		|| ArrayBuffer.isView(data)
+		|| typeof Blob != "undefined" && data instanceof Blob
 }
 /**
  * @param {unknown} error
@@ -82,8 +90,8 @@ function is_raw_message(data) {
  */
 function is_reconnectable(error) {
 	return error instanceof NetworkError
-	|| error instanceof TimeoutError
-	|| error instanceof SocketError && reconnect_codes.has(error.code)
+		|| error instanceof TimeoutError
+		|| error instanceof SocketError && reconnect_codes.has(error.code)
 }
 /**
  * @param {SocketSetup} setup
@@ -119,6 +127,140 @@ export function open_socket(setup) {
 	/** @type {ReturnType<typeof setTimeout> | undefined} */
 	let timer
 	const unlink = link_signal(closed, options.signal ?? void 0)
+	if (closed.signal.aborted) {
+		status = "closed"
+	} else {
+		on_abort(
+			closed.signal,
+			() => {
+				unlink()
+				finish(void 0)
+			}
+		)
+	}
+	return {
+		/** @returns {AsyncIterableIterator<unknown>} */
+		[Symbol.asyncIterator]() {
+			/** @type {SocketLoop} */
+			const loop = {
+				buffer: [],
+				ended: closed.signal.aborted,
+				error: void 0,
+				head: 0,
+				wake: void 0
+			}
+			let finished = false
+			let started = false
+			return {
+				[Symbol.asyncIterator]() {
+					return this
+				},
+				async next() {
+					if (!started) {
+						started = true
+						if (!loop.ended) {
+							loops.add(loop)
+							start()
+						}
+					}
+					for (;;) {
+						if (finished) {
+							return { done: true, value: void 0 }
+						}
+						if (loop.head < loop.buffer.length) {
+							const message = loop.buffer[loop.head]
+							loop.buffer[loop.head++] = void 0
+							if (loop.head == loop.buffer.length) {
+								loop.buffer = []
+								loop.head = 0
+							} else if (loop.head > 1024 && loop.head * 2 > loop.buffer.length) {
+								loop.buffer = loop.buffer.slice(loop.head)
+								loop.head = 0
+							}
+							if (!(message instanceof Promise)) {
+								return { done: false, value: message }
+							}
+							/** @type {unknown} */
+							let value
+							try {
+								value = await message
+							} catch (error) {
+								if (finished) {
+									return { done: true, value: void 0 }
+								}
+								stop()
+								throw error
+							}
+							if (finished) {
+								return { done: true, value: void 0 }
+							}
+							return { done: false, value }
+						}
+						if (loop.error) {
+							const { value } = loop.error
+							stop()
+							throw value
+						}
+						if (loop.ended) {
+							return stop()
+						}
+						await new Promise(
+							resolve => {
+								loop.wake = () => resolve(void 0)
+							}
+						)
+						loop.wake = void 0
+					}
+				},
+				async return() {
+					return stop()
+				}
+			}
+			/** @returns {IteratorResult<unknown>} */
+			function stop() {
+				if (!finished) {
+					finished = true
+					loops.delete(loop)
+					loop.wake?.()
+				}
+				return { done: true, value: void 0 }
+			}
+		},
+		/**
+		 * @param {unknown} reason
+		 * @returns {void}
+		 */
+		cancel: reason => closed.abort(
+			new CancelError(reason ?? "Cancelled", summary)
+		),
+		/**
+		 * @param {unknown} data
+		 * @returns {boolean}
+		 */
+		send: data => {
+			if (closed.signal.aborted) {
+				throw closed.signal.reason instanceof CancelError
+					? closed.signal.reason
+					: new CancelError(closed.signal.reason, summary)
+			}
+			const payload = serialize(data)
+			if (status == "open" && current?.readyState == 1) {
+				write(payload)
+				return true
+			}
+			if (outbox_limit > 0) {
+				if (outbox.length >= outbox_limit) {
+					outbox.shift()
+				}
+				outbox.push(payload)
+			}
+			start()
+			return false
+		},
+		get status() {
+			return status
+		}
+	}
 	/**
 	 * @param {number} id
 	 * @returns {Promise<void>}
@@ -136,43 +278,52 @@ export function open_socket(setup) {
 		}
 		try {
 			const { redacted, url } = await setup.url()
-			if (id != generation) return
+			if (id != generation) {
+				return
+			}
 			summary.url = redacted
 			const socket = setup.create(url, options.protocols)
 			current = socket
 			socket.binaryType = "arraybuffer"
 			socket.onerror = noop
 			socket.onopen = () => {
-				if (id == generation) open(id)
+				if (id == generation) {
+					open(id)
+				}
 			}
 			socket.onmessage = (
 				/** @type {MessageEvent} */ event
 			) => {
-				if (id == generation) receive(event.data)
+				if (id == generation) {
+					receive(event.data)
+				}
 			}
 			socket.onclose = (
 				/** @type {CloseEvent} */ event
 			) => {
-				if (id != generation) return
+				if (id != generation) {
+					return
+				}
 				detach()
-				if (event.code == 1000) finish(void 0)
-				else lose(
-					generation,
-					event.code == 1005 || event.code == 1006
-						? new NetworkError(
-							new SocketError(event.code, event.reason, summary),
-							summary
-						)
-						: new SocketError(event.code, event.reason, summary)
-				)
+				if (event.code == 1000) {
+					finish(void 0)
+				} else {
+					lose(
+						generation,
+						event.code == 1005 || event.code == 1006
+							? new NetworkError(
+								new SocketError(event.code, event.reason, summary),
+								summary
+							)
+							: new SocketError(event.code, event.reason, summary)
+					)
+				}
 			}
 		} catch (error) {
 			lose(id, error)
 		}
 	}
-	/**
-	 * @returns {void}
-	 */
+	/** @returns {void} */
 	function detach() {
 		generation++
 		stop_waiting?.()
@@ -183,7 +334,9 @@ export function open_socket(setup) {
 		silence_timer = void 0
 		const socket = current
 		current = void 0
-		if (!socket) return
+		if (!socket) {
+			return
+		}
 		try {
 			socket.close(1000)
 		} catch {}
@@ -206,7 +359,9 @@ export function open_socket(setup) {
 			loop.wake?.()
 		}
 		loops.clear()
-		if (failed) setup.report(error)
+		if (failed) {
+			setup.report(error)
+		}
 	}
 	/**
 	 * @param {number} id
@@ -214,7 +369,9 @@ export function open_socket(setup) {
 	 * @returns {void}
 	 */
 	function lose(id, error) {
-		if (id != generation) return
+		if (id != generation) {
+			return
+		}
 		detach()
 		if (!reconnect || !is_reconnectable(error) || ++failures > (reconnect_count ?? (ever_opened ? Infinity : first_failures))) {
 			finish(error, true)
@@ -228,10 +385,6 @@ export function open_socket(setup) {
 		setup.report(error)
 		set_status("connecting")
 		const next = generation
-		function retry() {
-			stop_waiting?.()
-			if (next == generation) connect(next)
-		}
 		timer = setTimeout(retry, clamp_delay(delay))
 		if (typeof globalThis.addEventListener == "function") {
 			globalThis.addEventListener("online", retry)
@@ -241,6 +394,11 @@ export function open_socket(setup) {
 				globalThis.removeEventListener("online", retry)
 			}
 		}
+		/** @returns {void} */
+		function retry() {
+			stop_waiting?.()
+			connect(next)
+		}
 	}
 	/**
 	 * @param {number} id
@@ -258,9 +416,13 @@ export function open_socket(setup) {
 		set_status("open")
 		const pending = outbox
 		outbox = []
-		for (const data of pending) write(data)
+		for (const data of pending) {
+			write(data)
+		}
 		const heartbeat = options.heartbeat
-		if (!heartbeat) return
+		if (!heartbeat) {
+			return
+		}
 		const ping = serialize(heartbeat.message)
 		heartbeat_timer = setInterval(
 			() => {
@@ -294,7 +456,9 @@ export function open_socket(setup) {
 					message = JSON.parse(data)
 				} catch {}
 			}
-			if (options.parse) message = options.parse(message)
+			if (options.parse) {
+				message = options.parse(message)
+			}
 		} catch (error) {
 			finish(error, true)
 			return
@@ -304,8 +468,11 @@ export function open_socket(setup) {
 			message.then(
 				noop,
 				(/** @type {unknown} */ error) => {
-					if (id == generation) finish(error, true)
-					else setup.report(error)
+					if (id == generation) {
+						finish(error, true)
+					} else {
+						setup.report(error)
+					}
 				}
 			)
 		}
@@ -326,17 +493,19 @@ export function open_socket(setup) {
 	 * @returns {void}
 	 */
 	function set_status(next) {
-		if (status == next) return
+		if (status == next) {
+			return
+		}
 		status = next
 		try {
 			options.onStatus?.(next)
 		} catch {}
 	}
-	/**
-	 * @returns {void}
-	 */
+	/** @returns {void} */
 	function start() {
-		if (status != "idle") return
+		if (status != "idle") {
+			return
+		}
 		set_status("connecting")
 		connect(++generation)
 	}
@@ -349,127 +518,6 @@ export function open_socket(setup) {
 			/** @type {never} */(payload)/**/
 		)
 	}
-	if (closed.signal.aborted) status = "closed"
-	else {
-		on_abort(
-			closed.signal,
-			() => {
-				unlink()
-				finish(void 0)
-			}
-		)
-	}
-	return {
-		/**
-		 * @returns {AsyncIterableIterator<unknown>}
-		 */
-		[Symbol.asyncIterator]() {
-			/** @type {SocketLoop} */
-			const loop = {
-				buffer: [],
-				ended: closed.signal.aborted,
-				error: void 0,
-				head: 0,
-				wake: void 0
-			}
-			let finished = false
-			let started = false
-			/** @returns {IteratorResult<unknown>} */
-			function stop() {
-				if (!finished) {
-					finished = true
-					loops.delete(loop)
-					loop.wake?.()
-				}
-				return { done: true, value: void 0 }
-			}
-			return {
-				[Symbol.asyncIterator]() {
-					return this
-				},
-				async next() {
-					if (!started) {
-						started = true
-						if (!loop.ended) {
-							loops.add(loop)
-							start()
-						}
-					}
-					for (;;) {
-						if (finished) return { done: true, value: void 0 }
-						if (loop.head < loop.buffer.length) {
-							const message = loop.buffer[loop.head]
-							loop.buffer[loop.head++] = void 0
-							if (loop.head == loop.buffer.length) {
-								loop.buffer = []
-								loop.head = 0
-							} else if (loop.head > 1024 && loop.head * 2 > loop.buffer.length) {
-								loop.buffer = loop.buffer.slice(loop.head)
-								loop.head = 0
-							}
-							if (!(message instanceof Promise)) return { done: false, value: message }
-							/** @type {unknown} */
-							let value
-							try {
-								value = await message
-							} catch (error) {
-								if (finished) return { done: true, value: void 0 }
-								stop()
-								throw error
-							}
-							if (finished) return { done: true, value: void 0 }
-							return { done: false, value }
-						}
-						if (loop.error) {
-							const { value } = loop.error
-							stop()
-							throw value
-						}
-						if (loop.ended) return stop()
-						await new Promise(
-							resolve => {
-								loop.wake = () => resolve(void 0)
-							}
-						)
-						loop.wake = void 0
-					}
-				},
-				async return() {
-					return stop()
-				}
-			}
-		},
-		/**
-		 * @param {unknown} reason
-		 * @returns {void}
-		 */
-		cancel: reason => closed.abort(
-			new CancelError(reason ?? "Cancelled", summary)
-		),
-		/**
-		 * @param {unknown} data
-		 * @returns {boolean}
-		 */
-		send: data => {
-			if (closed.signal.aborted) throw closed.signal.reason instanceof CancelError
-				? closed.signal.reason
-				: new CancelError(closed.signal.reason, summary)
-			const payload = serialize(data)
-			if (status == "open" && current?.readyState == 1) {
-				write(payload)
-				return true
-			}
-			if (outbox_limit > 0) {
-				if (outbox.length >= outbox_limit) outbox.shift()
-				outbox.push(payload)
-			}
-			start()
-			return false
-		},
-		get status() {
-			return status
-		}
-	}
 }
 /**
  * @param {unknown} data