@mycroblog/mykit 0.0.0-placeholder.0

package/dist/problem.js

@@ -0,0 +1,98 @@
+/** The type of a problem that means no more than its HTTP status (RFC 9457 §4.2.1). */
+export const problemTypeAboutBlank = "about:blank";
+/**
+ * The error of an answer with a status of 400 or more: its RFC 9457 problem document.
+ *
+ * ```ts
+ * try { await api.POST("/statuses", { body }); }
+ * catch (e) { if (e instanceof ProblemError && e.type === "/api/v1/problems/blocking") { ... } }
+ * ```
+ *
+ * Branch on `type` and `status`, never on `title` or `detail`, which the server localizes from Accept-Language. The
+ * members beyond the standard ones (such as `reason`) are in `problem`.
+ */
+export class ProblemError extends Error {
+    name = "ProblemError";
+    /** The whole problem document, extension members included. */
+    problem;
+    /** The headers of the answer, such as Retry-After and WWW-Authenticate. */
+    headers;
+    constructor(problem, headers) {
+        super(problemMessage(problem));
+        this.problem = problem;
+        this.headers = headers;
+    }
+    /** The URI that identifies the problem type, `about:blank` when the problem means no more than its status. */
+    get type() {
+        return this.problem.type;
+    }
+    /** The HTTP status of the answer. */
+    get status() {
+        return this.problem.status;
+    }
+    /** The localized summary of the problem type. */
+    get title() {
+        return this.problem.title;
+    }
+    /** The localized explanation of this occurrence. */
+    get detail() {
+        return this.problem.detail;
+    }
+}
+function problemMessage(p) {
+    let s = `mykit: ${String(p.status)} ${p.type}`;
+    if (p.title !== "")
+        s += `: ${p.title}`;
+    if (p.detail !== undefined && p.detail !== "")
+        s += `: ${p.detail}`;
+    return s;
+}
+/**
+ * Reads the problem of an error answer. An answer that is no problem document (from a proxy, say) becomes a problem
+ * of type about:blank with the answer's status.
+ */
+export async function problemFromResponse(response) {
+    let doc = {};
+    if (isJSON(response.headers.get("Content-Type"))) {
+        try {
+            const parsed = JSON.parse(await response.text());
+            if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed))
+                doc = parsed;
+        }
+        catch {
+            // Not JSON after all: the fallback below.
+        }
+    }
+    else {
+        await response.body?.cancel();
+    }
+    const problem = {
+        ...doc,
+        type: typeof doc["type"] === "string" && doc["type"] !== "" ? doc["type"] : problemTypeAboutBlank,
+        title: typeof doc["title"] === "string" && doc["title"] !== "" ? doc["title"] : response.statusText,
+        // The status of the answer is the one that happened, whatever the document says.
+        status: response.status,
+    };
+    if (typeof doc["detail"] !== "string")
+        delete problem.detail;
+    return new ProblemError(problem, response.headers);
+}
+/** Whether a Content-Type is JSON, application/problem+json among them. */
+function isJSON(contentType) {
+    const mt = contentType?.split(";")[0]?.trim().toLowerCase() ?? "";
+    return mt === "application/json" || mt.endsWith("+json");
+}
+/**
+ * The failure to get an answer from the server: the connection, TLS, or the fetch implementation. Its `cause` is the
+ * error of `fetch`. An aborted request is not one: it rejects with the reason of its signal (an AbortError).
+ */
+export class NetworkError extends Error {
+    name = "NetworkError";
+    method;
+    url;
+    constructor(method, url, cause) {
+        super(`mykit: ${method} ${url}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        this.method = method;
+        this.url = url;
+    }
+}