async-lube 2.0.0 → 2.1.0

package/src/http/response.js

@@ -42,17 +42,15 @@ function decode_bytes(bytes, charset) {
  * @returns {string | undefined}
  */
 function decode_korean(bytes) {
-	if (!get_cp949_regex().test(bytes)) return
+	if (!get_cp949_regex().test(bytes)) {
+		return
+	}
 	let korean
 	try {
 		korean = decode_bytes(bytes, "euc-kr")
 	} catch {
 		return
 	}
-	for (let i = 0; i < korean.length; i++) {
-		const code = korean.charCodeAt(i)
-		if (code >= 0x80 && code < 0xa0) return
-	}
 	return reads_as_latin1(bytes) ? void 0 : korean
 }
 /**
@@ -75,11 +73,11 @@ function decode_plain_name(name) {
 	}
 	return decoded
 }
-/**
- * @returns {RegExp}
- */
+/** @returns {RegExp} */
 function get_cp949_regex() {
-	if (cp949_regex) return cp949_regex
+	if (cp949_regex) {
+		return cp949_regex
+	}
 	let uhc = false
 	try {
 		uhc = decode_bytes("\x8c\x63", "euc-kr") == "똠"
@@ -105,20 +103,25 @@ export function get_file_name(response, url) {
 			hex => String.fromCharCode(parseInt(hex.slice(1), 16))
 		)
 		try {
-			const decoded = byte_string_regex.test(bytes)
-				? decode_bytes(bytes, extended?.[1] || "utf-8")
-				: ""
-			if (decoded) return decoded
+			const decoded = decode_bytes(bytes, extended?.[1] || "utf-8")
+			if (decoded) {
+				return decoded
+			}
 		} catch {}
 	}
 	const plain = plain_file_name_regex.exec(disposition)
 	const name = plain?.[1]?.replace(/\\(.)/g, "$1") ?? plain?.[2]?.trim()
-	if (name) return decode_plain_name(name)
+	if (name) {
+		return decode_plain_name(name)
+	}
 	const segment = new URL(url, "http://localhost").pathname.split("/").pop()
+	if (!segment) {
+		return "download"
+	}
 	try {
-		return segment ? decodeURIComponent(segment) : "download"
+		return decodeURIComponent(segment)
 	} catch {
-		return segment || "download"
+		return segment
 	}
 }
 /**
@@ -188,10 +191,16 @@ export async function read_body(response, as, method, url) {
 	case "text":
 		return response.text()
 	}
-	if (method == "HEAD" || null_body_statuses.has(response.status)) return
+	if (method == "HEAD" || null_body_statuses.has(response.status)) {
+		return
+	}
 	const type = response.headers.get("Content-Type") ?? ""
-	if (json_type_regex.test(type)) return parse_json(await response.text())
-	if (type && !text_type_regex.test(type)) return response.blob()
+	if (json_type_regex.test(type)) {
+		return parse_json(await response.text())
+	}
+	if (type && !text_type_regex.test(type)) {
+		return response.blob()
+	}
 	const text = await response.text()
 	return type || text ? text : void 0
 }
@@ -200,12 +209,18 @@ export async function read_body(response, as, method, url) {
  * @returns {Promise<unknown>}
  */
 export async function read_error_data(response) {
-	if (null_body_statuses.has(response.status)) return
+	if (null_body_statuses.has(response.status)) {
+		return
+	}
 	const type = response.headers.get("Content-Type") ?? ""
 	try {
-		if (type && !json_type_regex.test(type) && !text_type_regex.test(type)) return await response.blob()
+		if (type && !json_type_regex.test(type) && !text_type_regex.test(type)) {
+			return await response.blob()
+		}
 		const text = await response.text()
-		if (!json_type_regex.test(type)) return text || void 0
+		if (!json_type_regex.test(type)) {
+			return text || void 0
+		}
 		try {
 			return parse_json(text)
 		} catch {
@@ -220,7 +235,9 @@ export async function read_error_data(response) {
  * @returns {AsyncGenerator<StreamRecord, void, undefined>}
  */
 async function* read_events(response) {
-	if (!response.body) return
+	if (!response.body) {
+		return
+	}
 	const reader = response.body.pipeThrough(new TextDecoderStream())
 		.getReader()
 	let buffer = ""
@@ -235,10 +252,14 @@ async function* read_events(response) {
 	try {
 		for (;;) {
 			const { done, value } = await reader.read()
-			if (done) return
+			if (done) {
+				return
+			}
 			const text = pending_cr && value.startsWith("\n") ? value.slice(1) : value
 			pending_cr = false
-			if (!text) continue
+			if (!text) {
+				continue
+			}
 			buffer += text
 			pending_cr = buffer.endsWith("\r")
 			const lines = buffer.split(line_break_regex)
@@ -265,7 +286,9 @@ async function* read_events(response) {
 					retry = void 0
 					continue
 				}
-				if (line.startsWith(":")) continue
+				if (line.startsWith(":")) {
+					continue
+				}
 				const colon = line.indexOf(":")
 				const field = colon < 0 ? line : line.slice(0, colon)
 				const field_value = colon < 0
@@ -273,10 +296,13 @@ async function* read_events(response) {
 					: line.slice(
 						line[colon + 1] == " " ? colon + 2 : colon + 1
 					)
-				if (field == "data") data.push(field_value)
-				else if (field == "event") event = field_value
-				else if (field == "id" && !field_value.includes("\0")) id = field_value
-				else if (field == "retry" && /^\d+$/.test(field_value)) {
+				if (field == "data") {
+					data.push(field_value)
+				} else if (field == "event") {
+					event = field_value
+				} else if (field == "id" && !field_value.includes("\0")) {
+					id = field_value
+				} else if (field == "retry" && /^\d+$/.test(field_value)) {
 					retry = +field_value
 					yield { retry, type: "retry" }
 				}
@@ -292,22 +318,30 @@ async function* read_events(response) {
  * @returns {AsyncGenerator<unknown, void, undefined>}
  */
 async function* read_lines(response) {
-	if (!response.body) return
+	if (!response.body) {
+		return
+	}
 	const reader = response.body.pipeThrough(new TextDecoderStream())
 		.getReader()
 	let buffer = ""
 	try {
 		for (;;) {
 			const { done, value } = await reader.read()
-			if (done) break
+			if (done) {
+				break
+			}
 			buffer += value
 			const lines = buffer.split("\n")
 			buffer = /** @type {string} */(lines.pop())/**/
 			for (const line of lines) {
-				if (line.trim()) yield JSON.parse(line)
+				if (line.trim()) {
+					yield JSON.parse(line)
+				}
 			}
 		}
-		if (buffer.trim()) yield JSON.parse(buffer)
+		if (buffer.trim()) {
+			yield JSON.parse(buffer)
+		}
 	} finally {
 		reader.cancel()
 			.catch(noop)
@@ -321,20 +355,34 @@ function reads_as_latin1(bytes) {
 	let in_word = false
 	for (let i = 0; i < bytes.length; i++) {
 		const first = bytes.charCodeAt(i)
-		if (first < 0x80) continue
-		if (first < 0xa0) return false
+		if (first < 0x80) {
+			continue
+		}
+		if (first < 0xa0) {
+			return false
+		}
 		const second = bytes.charCodeAt(i + 1)
 		if (second < 0x80 || i + 1 == bytes.length) {
 			in_word = true
 			continue
 		}
-		if (bytes.charCodeAt(i + 2) >= 0x80 || !is_latin1_letter(first) || !is_latin1_letter(second)) return false
+		if (bytes.charCodeAt(i + 2) >= 0x80 || !is_latin1_letter(first) || !is_latin1_letter(second)) {
+			return false
+		}
 		if (is_latin1_lower(first)) {
-			if (!is_latin1_lower(second)) return false
-			if (is_ascii_letter(bytes.charCodeAt(i - 1)) || is_ascii_letter(bytes.charCodeAt(i + 2))) in_word = true
+			if (!is_latin1_lower(second)) {
+				return false
+			}
+			if (is_ascii_letter(bytes.charCodeAt(i - 1)) || is_ascii_letter(bytes.charCodeAt(i + 2))) {
+				in_word = true
+			}
 		} else {
-			if (is_latin1_lower(second) && second != 0xdf) return false
-			if (is_ascii_upper(bytes.charCodeAt(i - 1)) && is_ascii_upper(bytes.charCodeAt(i + 2))) in_word = true
+			if (is_latin1_lower(second) && second != 0xdf) {
+				return false
+			}
+			if (is_ascii_upper(bytes.charCodeAt(i - 1)) && is_ascii_upper(bytes.charCodeAt(i + 2))) {
+				in_word = true
+			}
 		}
 		i++
 	}
@@ -358,7 +406,9 @@ export function to_progress(loaded, total) {
  * @returns {Response}
  */
 export function track_progress(response, on_progress) {
-	if (!on_progress || response.status < 200 || response.status > 599) return response
+	if (!on_progress || response.status < 200 || response.status > 599) {
+		return response
+	}
 	const notify = on_progress
 	if (!response.body) {
 		call_progress(
@@ -375,19 +425,16 @@ export function track_progress(response, on_progress) {
 		: void 0
 	let loaded = 0
 	let complete = false
-	/** @param {import("../../public.js").Progress} progress */
-	function report(progress) {
-		complete = progress.ratio == 1
-		call_progress(notify, progress)
-	}
 	report(to_progress(0, total))
 	const body = response.body.pipeThrough(
 		new TransformStream(
 			{
 				flush() {
-					if (!complete) report(
-						{ loaded, ratio: 1, total: loaded }
-					)
+					if (!complete) {
+						report(
+							{ loaded, ratio: 1, total: loaded }
+						)
+					}
 				},
 				transform(chunk, controller) {
 					loaded += chunk.byteLength
@@ -405,4 +452,12 @@ export function track_progress(response, on_progress) {
 			statusText: response.statusText
 		}
 	)
+	/**
+	 * @param {import("../../public.js").Progress} progress
+	 * @returns {void}
+	 */
+	function report(progress) {
+		complete = progress.ratio == 1
+		call_progress(notify, progress)
+	}
 }

package/src/http/retry.js

@@ -25,7 +25,9 @@ const retry_statuses = new Set(
  * @returns {void}
  */
 function check_delay(delay, name) {
-	if (delay == null || typeof delay == "function" || typeof delay == "number" && delay >= 0) return
+	if (delay == null || typeof delay == "function" || typeof delay == "number" && delay >= 0) {
+		return
+	}
 	throw TypeError(
 		`${name} must be non-negative milliseconds or a function`
 	)
@@ -36,20 +38,27 @@ function check_delay(delay, name) {
  * @returns {void}
  */
 export function check_reconnect(reconnect, kind) {
-	if (reconnect == null || typeof reconnect == "boolean") return
-	if (typeof reconnect != "object") throw TypeError(
-		`The reconnect of ${kind}() must be a boolean or { count, delay }`
-	)
+	if (reconnect == null || typeof reconnect == "boolean") {
+		return
+	}
+	if (typeof reconnect != "object") {
+		throw TypeError(
+			`The reconnect of ${kind}() must be a boolean or { count, delay }`
+		)
+	}
 	check_options(
 		reconnect,
 		[ "count", "delay" ],
 		kind,
 		"reconnect."
 	)
-	const { count, delay } = /** @type {import("../../public.js").ReconnectOptions} */(reconnect)/**/
-	if (count != null && !is_count(count)) throw TypeError(
-		`The reconnect count of ${kind}() must be a non-negative integer or Infinity`
-	)
+	/** @type {import("../../public.js").ReconnectOptions} */
+	const { count, delay } = reconnect
+	if (count != null && !is_count(count)) {
+		throw TypeError(
+			`The reconnect count of ${kind}() must be a non-negative integer or Infinity`
+		)
+	}
 	check_delay(
 		delay,
 		`The reconnect delay of ${kind}()`
@@ -61,16 +70,22 @@ export function check_reconnect(reconnect, kind) {
  * @returns {void}
  */
 export function check_retry(retry, kind) {
-	if (retry == null) return
+	if (retry == null) {
+		return
+	}
 	if (typeof retry == "number") {
-		if (!is_count(retry)) throw TypeError(
-			`The retry count of ${kind}() must be a non-negative integer or Infinity`
-		)
+		if (!is_count(retry)) {
+			throw TypeError(
+				`The retry count of ${kind}() must be a non-negative integer or Infinity`
+			)
+		}
 		return
 	}
-	if (typeof retry != "object") throw TypeError(
-		`The retry of ${kind}() must be a non-negative integer or { count, delay, when }`
-	)
+	if (typeof retry != "object") {
+		throw TypeError(
+			`The retry of ${kind}() must be a non-negative integer or { count, delay, when }`
+		)
+	}
 	check_options(
 		retry,
 		[ "count", "delay", "when" ],
@@ -78,16 +93,20 @@ export function check_retry(retry, kind) {
 		"retry."
 	)
 	const { count, delay, when } = /** @type {import("../../public.js").RetryOptions} */(retry)/**/
-	if (!is_count(count)) throw TypeError(
-		`The retry count of ${kind}() must be a non-negative integer or Infinity`
-	)
+	if (!is_count(count)) {
+		throw TypeError(
+			`The retry count of ${kind}() must be a non-negative integer or Infinity`
+		)
+	}
 	check_delay(
 		delay,
 		`The retry delay of ${kind}()`
 	)
-	if (when != null && typeof when != "function") throw TypeError(
-		`The retry when of ${kind}() must be a function`
-	)
+	if (when != null && typeof when != "function") {
+		throw TypeError(
+			`The retry when of ${kind}() must be a function`
+		)
+	}
 }
 /**
  * @param {number} attempt
@@ -131,7 +150,9 @@ export function get_reconnect_wait(reconnect, failures, error) {
  */
 export function get_retry_delay(error, attempt) {
 	const ms = read_retry_after(error)
-	if (ms == null) return get_backoff(attempt)
+	if (ms == null) {
+		return get_backoff(attempt)
+	}
 	return ms <= max_retry_after ? ms : void 0
 }
 /**
@@ -141,7 +162,9 @@ export function get_retry_delay(error, attempt) {
  * @returns {number | undefined}
  */
 export function get_retry_wait(retry, attempt, error) {
-	if (typeof retry.delay == "number") return retry.delay
+	if (typeof retry.delay == "number") {
+		return retry.delay
+	}
 	const fallback = get_retry_delay(error, attempt)
 	return retry.delay ? retry.delay(attempt, error, fallback) : fallback
 }
@@ -165,8 +188,8 @@ export function is_idempotent(method) {
  */
 export function is_retryable(error) {
 	return error instanceof NetworkError
-	|| error instanceof TimeoutError
-	|| error instanceof HttpError && retry_statuses.has(error.status)
+		|| error instanceof TimeoutError
+		|| error instanceof HttpError && retry_statuses.has(error.status)
 }
 /**
  * @param {unknown} error
@@ -174,7 +197,9 @@ export function is_retryable(error) {
  */
 export function read_retry_after(error) {
 	const retry_after = error instanceof HttpError ? error.headers.get("Retry-After") : null
-	if (!retry_after) return
+	if (!retry_after) {
+		return
+	}
 	const ms = /^\s*\d+\s*$/.test(retry_after)
 		? Number(retry_after) * 1000
 		: Date.parse(retry_after) - Date.now()