async-lube 2.0.0 → 2.1.0

package/src/flow/streams.js

@@ -29,13 +29,16 @@ function end_source(c, record, failure) {
 	record.source_error = failure
 	if (record.status == "waiting" && c.run_status == "running") {
 		clearTimeout(record.timer)
-		if (failure) fail_input(c, record, failure.error)
-		else settle(
-			c,
-			record.node.name,
-			"skipped",
-			void 0
-		)
+		if (failure) {
+			fail_input(c, record, failure.error)
+		} else {
+			settle(
+				c,
+				record.node.name,
+				"skipped",
+				void 0
+			)
+		}
 	} else if (failure && settled_statuses.has(record.status)) {
 		c.streaming = true
 		try {
@@ -43,12 +46,18 @@ function end_source(c, record, failure) {
 		} finally {
 			c.streaming = false
 		}
-		if (c.run_status != "running") return
+		if (c.run_status != "running") {
+			return
+		}
 		enter(c, [ record.node.name ], "*")
-		for (const name of c.records.keys()) try_start(c, name)
+		for (const name of c.records.keys()) {
+			try_start(c, name)
+		}
 		drain(c)
 		schedule(c)
-	} else return
+	} else {
+		return
+	}
 	report(c)
 	publish(c)
 }
@@ -61,11 +70,13 @@ function end_source(c, record, failure) {
 function is_full(c, source, dependents) {
 	for (const dependent of dependents) {
 		const target = get_record(c, dependent)
-		const limit = target.node.options.limit ?? Infinity
+		const limit = /** @type {number} */(target.node.options.limit)/**/
 		const waiting = target.node.arrive?.[source] == "queue"
 			? (target.queued?.get(source)?.length ?? 0) - (active_statuses.has(target.status) ? 1 : 0)
 			: target.backlog.length - target.backlog_head
-		if (waiting >= limit) return true
+		if (waiting >= limit) {
+			return true
+		}
 	}
 	return false
 }
@@ -74,11 +85,15 @@ function is_full(c, source, dependents) {
  * @returns {void}
  */
 export function start_pumps(c) {
-	if (c.pumping || c.run_status != "running") return
+	if (c.pumping || c.run_status != "running") {
+		return
+	}
 	c.pumping = true
 	for (const record of c.records.values()) {
 		const { dependents, name, source } = record.node
-		if (!source) continue
+		if (!source) {
+			continue
+		}
 		const pressed = dependents.filter(
 			dependent => get_record(c, dependent).node.options.overflow == "wait"
 		)
@@ -105,7 +120,9 @@ export function start_pumps(c) {
 			try {
 				for (;;) {
 					const step = await reader.next()
-					if (stopped) return
+					if (stopped) {
+						return
+					}
 					if (step.done) {
 						end_source(c, record, void 0)
 						return
@@ -121,10 +138,14 @@ export function start_pumps(c) {
 							resolve => c.room_waiters.push(resolve)
 						)
 					}
-					if (stopped) return
+					if (stopped) {
+						return
+					}
 				}
 			} catch (error) {
-				if (!stopped) end_source(c, record, { error })
+				if (!stopped) {
+					end_source(c, record, { error })
+				}
 			}
 		})()
 	}
@@ -135,7 +156,9 @@ export function start_pumps(c) {
  */
 export function stop_pumps(c) {
 	c.pumping = false
-	for (const stop of c.pumps.splice(0)) stop()
+	for (const stop of c.pumps.splice(0)) {
+		stop()
+	}
 	wake_room(c)
 }
 /**
@@ -143,5 +166,7 @@ export function stop_pumps(c) {
  * @returns {void}
  */
 export function wake_room(c) {
-	for (const resolve of c.room_waiters.splice(0)) resolve(void 0)
+	for (const resolve of c.room_waiters.splice(0)) {
+		resolve(void 0)
+	}
 }

package/src/flow/subflows.js

@@ -22,29 +22,39 @@ function check_path(program, path, full, need) {
 	const head = dot < 0 ? path : path.slice(0, dot)
 	const name = program.name_of(head)
 	const node = name == null ? void 0 : program.node_of(name)
-	if (!node) throw Error(
-		`"${head}" is not added to the flow`
-	)
-	if (dot < 0) {
-		if (need == "input" && node.kind != "input") throw Error(
-			`Flow node "${node.name}" is not an input`
+	if (!node) {
+		throw Error(
+			`"${head}" is not added to the flow`
 		)
+	}
+	if (dot < 0) {
+		if (need == "input" && node.kind != "input") {
+			throw Error(
+				`Flow node "${node.name}" is not an input`
+			)
+		}
 		return
 	}
-	if (node.kind != "flow") throw Error(
-		`Flow node "${node.name}" is not a flow, so "${full}" names nothing`
-	)
+	if (node.kind != "flow") {
+		throw Error(
+			`Flow node "${node.name}" is not a flow, so "${full}" names nothing`
+		)
+	}
 	let rest = path.slice(dot + 1)
 	if (node.each) {
 		const next = rest.indexOf(".")
 		const key = next < 0 ? rest : rest.slice(0, next)
-		if (!is_index(key)) throw Error(
-			`Flow node "${node.name}" has no item ${key}`
-		)
+		if (!is_index(key)) {
+			throw Error(
+				`Flow node "${node.name}" has no item ${key}`
+			)
+		}
 		rest = next < 0 ? "" : rest.slice(next + 1)
 	}
 	if (!rest) {
-		if (need == "any") return
+		if (need == "any") {
+			return
+		}
 		throw Error(
 			`The path "${full}" does not name ${need == "input" ? "an input" : "a node"}`
 		)
@@ -69,14 +79,18 @@ export function check_snapshot_names(program, path, problems) {
 		const name = path + node.name
 		if (!node.named) {
 			const message = `Flow node "${name}" has no name of its own, so a snapshot cannot find it after the code changes: add it with a name option`
-			if (!problems) throw Error(message)
+			if (!problems) {
+				throw Error(message)
+			}
 			problems.push(message)
 		}
-		if (node.sub) check_snapshot_names(
-			compile(node.sub),
-			name + ".",
-			problems
-		)
+		if (node.sub) {
+			check_snapshot_names(
+				compile(node.sub),
+				name + ".",
+				problems
+			)
+		}
 	}
 }
 /**
@@ -86,17 +100,22 @@ export function check_snapshot_names(program, path, problems) {
  * @returns {void}
  */
 function count_sub(record, status, change) {
-	if (status == "running") record.sub_running += change
-	else if (status == "waiting") record.sub_waiting += change
+	if (status == "running") {
+		record.sub_running += change
+	} else if (status == "waiting") {
+		record.sub_waiting += change
+	}
 }
 /**
  * @param {NodeRecord} record
  * @returns {string[]}
  */
 export function failed_sub_keys(record) {
-	if (record.sub_runs.size) return [ ...record.sub_runs ].filter(
-		([ , sub_run ]) => sub_run[FAILURES]()
-	).map(([ key ]) => key)
+	if (record.sub_runs.size) {
+		return [ ...record.sub_runs ].filter(
+			([ , sub_run ]) => sub_run[FAILURES]()
+		).map(([ key ]) => key)
+	}
 	return Object.entries(record.resume_subs ?? {}).filter(
 		([ , sub ]) => has_snapshot_failures(sub)
 	)
@@ -114,9 +133,11 @@ export function find_sub_run(c, path, need) {
 		c,
 		name_or_throw(c, path.slice(0, dot))
 	)
-	if (record.node.kind != "flow") throw Error(
-		`Flow node "${record.node.name}" is not a flow, so "${path}" names nothing`
-	)
+	if (record.node.kind != "flow") {
+		throw Error(
+			`Flow node "${record.node.name}" is not a flow, so "${path}" names nothing`
+		)
+	}
 	let rest = path.slice(dot + 1)
 	let key = ""
 	if (record.node.each) {
@@ -125,12 +146,16 @@ export function find_sub_run(c, path, need) {
 		rest = next < 0 ? "" : rest.slice(next + 1)
 	}
 	const sub_run = record.status == "running" ? record.sub_runs.get(key) : void 0
-	if (sub_run && active_statuses.has(sub_run.status)) return [ sub_run, rest ]
+	if (sub_run && active_statuses.has(sub_run.status)) {
+		return [ sub_run, rest ]
+	}
 	check_path(c.program, path, path, need)
 	const count = record.status == "running" ? record.items?.length : void 0
-	if (count != null && Number(key) >= count) throw Error(
-		`Flow node "${record.node.name}" has no item ${key}`
-	)
+	if (count != null && Number(key) >= count) {
+		throw Error(
+			`Flow node "${record.node.name}" has no item ${key}`
+		)
+	}
 	return [ void 0, rest ]
 }
 /**
@@ -142,7 +167,9 @@ export function flatten_snapshot_errors(snapshot) {
 	const all = { ...snapshot.errors }
 	for (const [ name, data ] of Object.entries(snapshot.nodes)) {
 		for (const [ key, sub ] of Object.entries(data.subs ?? {})) {
-			for (const [ sub_key, error ] of Object.entries(flatten_snapshot_errors(sub))) all[(key ? name + "." + key : name) + "." + sub_key] = error
+			for (const [ sub_key, error ] of Object.entries(flatten_snapshot_errors(sub))) {
+				all[(key ? name + "." + key : name) + "." + sub_key] = error
+			}
 		}
 	}
 	return all
@@ -185,18 +212,6 @@ export async function run_sub(
 	const index = key ? Number(key) : c.item_index
 	/** @type {FlowStatus} */
 	let reported = "running"
-	/**
-	 * @param {FlowStatus} status
-	 * @returns {void}
-	 */
-	function on_change(status) {
-		count_sub(record, reported, -1)
-		count_sub(record, status, 1)
-		reported = status
-		c.version++
-		report(c)
-		schedule(c)
-	}
 	count_sub(record, reported, 1)
 	const sub_run = start_run(
 		compile(
@@ -220,7 +235,9 @@ export async function run_sub(
 			},
 		(c.trace_path ? c.trace_path + "." : "") + record.node.name + (key ? "." + key : "")
 	)
-	if (record.retrying && sub_snapshot) sub_run.retry()
+	if (record.retrying && sub_snapshot) {
+		sub_run.retry()
+	}
 	record.sub_runs.set(key, sub_run)
 	const sends = record.sends?.get(key)
 	if (sends) {
@@ -233,11 +250,25 @@ export async function run_sub(
 	}
 	try {
 		const value = await sub_run
-		if (record.sub_runs.get(key) == sub_run && !sub_run[FAILURES]()) record.sub_runs.delete(key)
+		if (record.sub_runs.get(key) == sub_run && !sub_run[FAILURES]()) {
+			record.sub_runs.delete(key)
+		}
 		return value
 	} finally {
 		sub_run[STOP]()
 	}
+	/**
+	 * @param {FlowStatus} status
+	 * @returns {void}
+	 */
+	function on_change(status) {
+		count_sub(record, reported, -1)
+		count_sub(record, status, 1)
+		reported = status
+		c.version++
+		report(c)
+		schedule(c)
+	}
 }
 /**
  * @param {RunContext} c
@@ -267,18 +298,27 @@ export function send_path(c, path, value) {
 		return
 	}
 	check_path(c.program, path, path, "input")
-	if (record.abandoned && !active_statuses.has(record.status)) return
+	if (record.abandoned && !active_statuses.has(record.status)) {
+		return
+	}
 	const count = record.status == "running" ? record.items?.length : void 0
-	if (count != null && Number(key) >= count) throw Error(
-		`Flow node "${name}" has no item ${key}`
-	)
+	if (count != null && Number(key) >= count) {
+		throw Error(
+			`Flow node "${name}" has no item ${key}`
+		)
+	}
 	const item = record.items?.[Number(key)]
 	const is_kept = record.sub_runs.has(key) || !!record.resume_subs?.[key] || !!item?.failed
-	if (!is_kept && (record.status == "done" || record.status == "skipped" || item)) return
+	if (!is_kept && (record.status == "done" || record.status == "skipped" || item)) {
+		return
+	}
 	record.sends ??= new Map()
 	const sends = record.sends.get(key)
-	if (sends) sends.push([ rest, value ])
-	else record.sends.set(key, [ [ rest, value ] ])
+	if (sends) {
+		sends.push([ rest, value ])
+	} else {
+		record.sends.set(key, [ [ rest, value ] ])
+	}
 }
 /**
  * @param {NodeRecord} record

package/src/http/config.js

@@ -13,7 +13,9 @@ export const hook_names = /** @type {const} */([
  * @returns {void}
  */
 export function call_hook(hook, ...args) {
-	if (!hook) return
+	if (!hook) {
+		return
+	}
 	try {
 		Promise.resolve(hook(...args))
 			.catch(noop)
@@ -26,9 +28,11 @@ export function call_hook(hook, ...args) {
  */
 export async function merge_headers(source, target) {
 	const init = typeof source == "function" ? await source() : source
-	if (init) new Headers(init).forEach(
-		(value, key) => target.set(key, value)
-	)
+	if (init) {
+		new Headers(init).forEach(
+			(value, key) => target.set(key, value)
+		)
+	}
 }
 /**
  * @param {import("../../public.js").Hooks} parent
@@ -65,7 +69,9 @@ export function omit_keys(source, keys) {
 	/** @type {Record<string, unknown>} */
 	const init = {}
 	for (const key of Object.keys(source)) {
-		if (!keys.has(key)) init[key] = source[key]
+		if (!keys.has(key)) {
+			init[key] = source[key]
+		}
 	}
 	return init
 }

package/src/http/index.js

@@ -28,10 +28,14 @@ let client_count = 0
  * @returns {string}
  */
 function to_socket_url(url) {
-	if (scheme_regex.test(url)) return url.replace(/^http(s?):/i, "ws$1:")
-	if (typeof location == "undefined") throw TypeError(
-		`The URL "${url}" is relative: set base, or use an absolute URL`
-	)
+	if (scheme_regex.test(url)) {
+		return url.replace(/^http(s?):/i, "ws$1:")
+	}
+	if (typeof location == "undefined") {
+		throw TypeError(
+			`The URL "${url}" is relative: set base, or use an absolute URL`
+		)
+	}
 	return new URL(url, location.href).href.replace(/^http(s?):/i, "ws$1:")
 }
 /**
@@ -70,15 +74,16 @@ function http(
 			options,
 			false
 		),
-		/**
-		 * @param {import("../../public.js").ExtendConfig} next
-		 */
+		/** @param {import("../../public.js").ExtendConfig} next */
 		extend: next => {
 			/** @type {Record<string, unknown>} */
 			const merged = { ...config }
 			for (const [ key, value ] of Object.entries(next)) {
-				if (value === null) delete merged[key]
-				else if (value !== void 0) merged[key] = value
+				if (value === null) {
+					delete merged[key]
+				} else if (value !== void 0) {
+					merged[key] = value
+				}
 			}
 			if (config.headers && next.headers) {
 				merged["headers"] = async () => {
@@ -91,7 +96,9 @@ function http(
 					return headers
 				}
 			}
-			if (config.on && next.on) merged["on"] = merge_hooks(config.on, next.on)
+			if (config.on && next.on) {
+				merged["on"] = merge_hooks(config.on, next.on)
+			}
 			return http(merged, shared)
 		},
 		/**
@@ -207,9 +214,11 @@ function http(
 			{
 				create: (url, protocols) => {
 					const Socket = config.WebSocket ?? globalThis.WebSocket
-					if (!Socket) throw TypeError(
-						"WebSocket is not available: pass WebSocket in the config"
-					)
+					if (!Socket) {
+						throw TypeError(
+							"WebSocket is not available: pass WebSocket in the config"
+						)
+					}
 					return protocols == null ? new Socket(url) : new Socket(url, protocols)
 				},
 				options,
@@ -221,7 +230,9 @@ function http(
 					/** @type {Record<string, string>} */
 					const hidden = {}
 					if (typeof options.params == "function") {
-						for (const key of Object.keys(extra ?? {})) hidden[key] = "***"
+						for (const key of Object.keys(extra ?? {})) {
+							hidden[key] = "***"
+						}
 					}
 					return {
 						redacted: to_socket_url(

package/src/http/refresh.js

@@ -60,7 +60,9 @@ export function get_refresh_state(refresher) {
  */
 async function refresh(c, state, generation, error) {
 	if (generation != state.generation) {
-		if (generation == state.failed_generation) throw error
+		if (generation == state.failed_generation) {
+			throw error
+		}
 		return
 	}
 	if (!state.refreshing) {
@@ -79,13 +81,17 @@ async function refresh(c, state, generation, error) {
 			.then(c.config.refresh)
 			.then(
 				() => {
-					if (state.generation != generation) return
+					if (state.generation != generation) {
+						return
+					}
 					clearTimeout(state.timer)
 					state.generation++
 					state.refreshing = void 0
 				},
 				(/** @type {unknown} */ reason) => {
-					if (state.generation == generation) fail_refresh(c, state, error, reason)
+					if (state.generation == generation) {
+						fail_refresh(c, state, error, reason)
+					}
 					throw reason
 				}
 			)
@@ -116,7 +122,9 @@ async function refresh(c, state, generation, error) {
  * @returns {void}
  */
 export function reject_refreshed(c, state, generation, error) {
-	if (state.unauthorized_generation == generation) return
+	if (state.unauthorized_generation == generation) {
+		return
+	}
 	state.unauthorized_generation = generation
 	call_hook(
 		c.config.on?.unauthorized,
@@ -132,7 +140,6 @@ export function reject_refreshed(c, state, generation, error) {
  * @returns {void}
  */
 function time_out_refresh(c, state, error, timeout_error) {
-	if (!state.refreshing) return
 	const controller = state.controller
 	state.time_out?.(timeout_error)
 	fail_refresh(c, state, error, timeout_error)
@@ -171,7 +178,9 @@ export async function wait_refresh(
 		: void 0
 	const waiting = refresh(c, state, generation, error)
 	const joined = state.generation == generation && state.refreshing != null
-	if (joined) state.waiters++
+	if (joined) {
+		state.waiters++
+	}
 	try {
 		await race_signal(waiting, controller.signal)
 	} catch (reason) {
@@ -182,13 +191,21 @@ export async function wait_refresh(
 			)
 			: void 0
 		if (joined && state.generation == generation && state.refreshing) {
-			if (timeout_error) state.timed_out = timeout_error
-			if (--state.waiters == 0 && state.timed_out) time_out_refresh(c, state, error, state.timed_out)
+			if (timeout_error) {
+				state.timed_out = timeout_error
+			}
+			if (--state.waiters == 0 && state.timed_out) {
+				time_out_refresh(c, state, error, state.timed_out)
+			}
+		}
+		if (signal.aborted) {
+			throw signal.reason instanceof CancelError
+				? signal.reason
+				: new CancelError(signal.reason, summary)
+		}
+		if (timeout_error) {
+			throw timeout_error
 		}
-		if (signal.aborted) throw signal.reason instanceof CancelError
-			? signal.reason
-			: new CancelError(signal.reason, summary)
-		if (timeout_error) throw timeout_error
 		throw reason instanceof TimeoutError
 			? new TimeoutError(reason.timeout, summary)
 			: reason