async-lube 2.0.0 → 2.1.0

package/src/redial.js

@@ -0,0 +1,129 @@
+import { check_options } from "./options.js"
+import { clamp_delay, on_abort } from "./signal.js"
+/**
+ * Keeps one connection up: calls `connect` at once and again after each close, waiting `base` milliseconds
+ * after a connection that opened and doubling the wait up to `most` after each one that closed without opening,
+ * until the `signal` aborts. The connector tells it when its connection opened and closed, so a WebSocket or a
+ * server stream reconnects. The result resolves once the signal has aborted and the connection in hand has closed.
+ * `connect` gets `{ attempt, signal, open, close }`: `attempt` counts every call from 1, so it can rotate addresses;
+ * `signal` of the connection aborts when the outer signal does, so close the connection on it; `open()` marks the
+ * connection up and resets the wait; `close()` ends it, and only its first call counts. A `connect` that throws or
+ * returns a promise that rejects counts as a close.
+ * @example
+ * const stop = new AbortController()
+ * const stopped = redial(
+ * 	({ attempt, signal, open, close }) => {
+ * 		const socket = new WebSocket(urls[(attempt - 1) % urls.length])
+ * 		socket.onopen = open
+ * 		socket.onclose = close
+ * 		signal.addEventListener("abort", () => socket.close(), { once: true })
+ * 	},
+ * 	{ signal: stop.signal, base: 1000, most: 30000 }
+ * )
+ * stop.abort()
+ * await stopped
+ * @param {(context: import("../public.js").RedialContext) => unknown} connect
+ * @param {import("../public.js").RedialOptions} options
+ * @returns {Promise<void>}
+ */
+export function redial(connect, options) {
+	check_options(
+		options,
+		[ "base", "most", "signal" ],
+		"redial"
+	)
+	const signal = options?.signal
+	if (!(signal instanceof AbortSignal)) {
+		throw TypeError(
+			"The signal of redial() must be an AbortSignal"
+		)
+	}
+	const base = options.base ?? 1000
+	const most = options.most ?? 30000
+	if (!(typeof base == "number" && base > 0)) {
+		throw TypeError(
+			"The base of redial() must be a positive number of milliseconds"
+		)
+	}
+	if (!(typeof most == "number" && most >= base)) {
+		throw TypeError(
+			"The most of redial() must be a number of milliseconds that is not less than base"
+		)
+	}
+	if (signal.aborted) {
+		return Promise.resolve()
+	}
+	return new Promise(
+		resolve => {
+			let count = 0
+			let failures = 0
+			/** @type {ReturnType<typeof setTimeout> | undefined} */
+			let timer
+			/** @type {AbortController | undefined} */
+			let current
+			const unlink = on_abort(
+				signal,
+				() => {
+					clearTimeout(timer)
+					if (current) {
+						current.abort(signal.reason)
+					} else {
+						resolve()
+					}
+				}
+			)
+			start()
+			/** @returns {void} */
+			function start() {
+				const controller = new AbortController()
+				let opened = false
+				let closed = false
+				current = controller
+				count++
+				try {
+					Promise.resolve(
+						connect(
+							{
+								attempt: count,
+								close,
+								open,
+								signal: controller.signal
+							}
+						)
+					).catch(close)
+				} catch {
+					close()
+				}
+				/** @returns {void} */
+				function close() {
+					if (closed) {
+						return
+					}
+					closed = true
+					current = void 0
+					if (signal.aborted) {
+						unlink()
+						resolve()
+						return
+					}
+					failures = opened ? 0 : failures + 1
+					timer = setTimeout(
+						start,
+						clamp_delay(
+							Math.min(
+								base * 2 ** Math.max(failures - 1, 0),
+								most
+							)
+						)
+					)
+				}
+				/** @returns {void} */
+				function open() {
+					if (!closed) {
+						opened = true
+					}
+				}
+			}
+		}
+	)
+}

package/src/signal.js

@@ -14,7 +14,9 @@ export function clamp_delay(ms) {
  * @returns {() => void}
  */
 export function link_signal(controller, signal) {
-	if (!signal) return noop
+	if (!signal) {
+		return noop
+	}
 	if (signal.aborted) {
 		controller.abort(signal.reason)
 		return noop
@@ -24,6 +26,7 @@ export function link_signal(controller, signal) {
 		() => controller.abort(signal.reason)
 	)
 }
+/** @returns {void} */
 export function noop() {}
 /**
  * @param {AbortSignal} signal
@@ -36,9 +39,12 @@ export function on_abort(signal, callback) {
 	if (!entry) {
 		/** @type {Set<() => void>} */
 		const callbacks = new Set()
+		/** @returns {void} */
 		function listener() {
 			abort_entries.delete(signal)
-			for (const call of [ ...callbacks ]) call()
+			for (const call of [ ...callbacks ]) {
+				call()
+			}
 		}
 		entry = { callbacks, listener }
 		abort_entries.set(signal, entry)
@@ -47,7 +53,9 @@ export function on_abort(signal, callback) {
 	const current = entry
 	current.callbacks.add(callback)
 	return () => {
-		if (!current.callbacks.delete(callback) || current.callbacks.size || abort_entries.get(signal) != current) return
+		if (!current.callbacks.delete(callback) || current.callbacks.size || abort_entries.get(signal) != current) {
+			return
+		}
 		abort_entries.delete(signal)
 		signal.removeEventListener("abort", current.listener)
 	}
@@ -113,7 +121,9 @@ export function sleep(ms, signal) {
  */
 export function sleep_until(deadline, signal) {
 	const left = deadline - Date.now()
-	if (left <= max_delay) return sleep(left, signal)
+	if (left <= max_delay) {
+		return sleep(left, signal)
+	}
 	return sleep(max_delay, signal)
 		.then(
 			() => sleep_until(deadline, signal)