@c9up/aurora 0.1.6 → 0.1.7

package/dist/http.js

@@ -0,0 +1,199 @@
+/**
+ * `HttpClient` — a small typed wrapper over `fetch` so call sites read
+ * `await http.get<User>("/auth/me")` instead of hand-rolling headers,
+ * `res.json()`, and status checks.
+ *
+ * - Auto JSON: a plain-object/array body is `JSON.stringify`-d with a
+ *   `Content-Type: application/json` header; a JSON response is parsed.
+ *   `FormData`/`Blob`/`URLSearchParams`/`string`/binary bodies pass through
+ *   untouched.
+ * - Bearer auth: a `token` (string or getter, read fresh per request) is sent
+ *   as `Authorization: Bearer …` unless the caller set the header themselves.
+ * - Errors: a non-2xx response rejects with an {@link HttpError} carrying the
+ *   status, the `Response`, and the parsed body.
+ *
+ * Node-free and isomorphic — uses the global `fetch` (browsers, Node 18+,
+ * Workers, Bun, Deno). Part of the client barrel.
+ */
+/** Thrown on a non-2xx response. Carries the status, the `Response`, and the parsed body. */
+export class HttpError extends Error {
+    status;
+    response;
+    data;
+    constructor(response, data) {
+        super(`HTTP ${response.status} ${response.statusText} for ${response.url}`);
+        this.name = "HttpError";
+        this.status = response.status;
+        this.response = response;
+        this.data = data;
+    }
+}
+/** Whether `body` should be JSON-encoded (vs. passed to `fetch` untouched). */
+function shouldJsonEncode(body) {
+    if (body === null || typeof body !== "object") {
+        return typeof body !== "string";
+    }
+    if (body instanceof FormData ||
+        body instanceof Blob ||
+        body instanceof URLSearchParams ||
+        body instanceof ArrayBuffer ||
+        ArrayBuffer.isView(body)) {
+        return false;
+    }
+    if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+        return false;
+    }
+    return true;
+}
+/** Case-insensitive header presence check. */
+function hasHeader(headers, name) {
+    const lower = name.toLowerCase();
+    for (const key of Object.keys(headers)) {
+        if (key.toLowerCase() === lower)
+            return true;
+    }
+    return false;
+}
+/** Parse a response by content-type; `null` for empty / no-content bodies. */
+async function parseBody(response) {
+    if (response.status === 204 || response.status === 205)
+        return null;
+    const type = response.headers.get("content-type") ?? "";
+    const text = await response.text();
+    if (text === "")
+        return null;
+    if (type.includes("application/json"))
+        return JSON.parse(text);
+    return text;
+}
+export class HttpClient {
+    #baseURL;
+    #headers;
+    #token;
+    #credentials;
+    constructor(options = {}) {
+        this.#baseURL = options.baseURL ?? "";
+        this.#headers = { ...options.headers };
+        this.#token = options.token;
+        this.#credentials = options.credentials;
+    }
+    /** Set a default header for every subsequent request (case-insensitive replace). Chainable. */
+    setHeader(name, value) {
+        this.#deleteHeader(name);
+        this.#headers[name] = value;
+        return this;
+    }
+    /** Merge several default headers at once. Chainable. */
+    setHeaders(headers) {
+        for (const [name, value] of Object.entries(headers)) {
+            this.setHeader(name, value);
+        }
+        return this;
+    }
+    /** Remove a default header (case-insensitive). Chainable. */
+    removeHeader(name) {
+        this.#deleteHeader(name);
+        return this;
+    }
+    /** A copy of the current default headers. */
+    getHeaders() {
+        return { ...this.#headers };
+    }
+    #deleteHeader(name) {
+        const lower = name.toLowerCase();
+        for (const key of Object.keys(this.#headers)) {
+            if (key.toLowerCase() === lower)
+                delete this.#headers[key];
+        }
+    }
+    get(url, options) {
+        return this.#request("GET", url, undefined, options);
+    }
+    delete(url, options) {
+        return this.#request("DELETE", url, undefined, options);
+    }
+    post(url, body, options) {
+        return this.#request("POST", url, body, options);
+    }
+    put(url, body, options) {
+        return this.#request("PUT", url, body, options);
+    }
+    patch(url, body, options) {
+        return this.#request("PATCH", url, body, options);
+    }
+    /** Send a request and return the raw `Response` (no parsing, no throw on non-2xx). */
+    raw(method, url, body, options = {}) {
+        return this.#send(method, url, body, options);
+    }
+    /** Derive a new client with merged defaults (e.g. a scope that adds a token). */
+    extend(options) {
+        return new HttpClient({
+            baseURL: options.baseURL ?? this.#baseURL,
+            headers: { ...this.#headers, ...options.headers },
+            token: options.token ?? this.#token,
+            credentials: options.credentials ?? this.#credentials,
+        });
+    }
+    #resolveToken(override) {
+        if (override !== undefined)
+            return override;
+        return typeof this.#token === "function" ? this.#token() : this.#token;
+    }
+    #buildUrl(url, query) {
+        const base = /^[a-z][a-z\d+\-.]*:\/\//i.test(url)
+            ? url
+            : this.#baseURL + url;
+        if (!query)
+            return base;
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== null && value !== undefined)
+                params.append(key, String(value));
+        }
+        const qs = params.toString();
+        if (qs === "")
+            return base;
+        return `${base}${base.includes("?") ? "&" : "?"}${qs}`;
+    }
+    #send(method, url, body, options) {
+        const headers = {
+            ...this.#headers,
+            ...options.headers,
+        };
+        const token = this.#resolveToken(options.token);
+        if (token != null && !hasHeader(headers, "authorization")) {
+            headers.Authorization = `Bearer ${token}`;
+        }
+        let payload;
+        if (body !== undefined && body !== null) {
+            if (shouldJsonEncode(body)) {
+                payload = JSON.stringify(body);
+                if (!hasHeader(headers, "content-type")) {
+                    headers["Content-Type"] = "application/json";
+                }
+            }
+            else {
+                // Already a valid BodyInit (string / FormData / Blob / …).
+                payload = body;
+            }
+        }
+        return fetch(this.#buildUrl(url, options.query), {
+            method,
+            headers,
+            body: payload,
+            signal: options.signal,
+            credentials: options.credentials ?? this.#credentials,
+        });
+    }
+    async #request(method, url, body, options = {}) {
+        const response = await this.#send(method, url, body, options);
+        const data = await parseBody(response);
+        if (!response.ok)
+            throw new HttpError(response, data);
+        // `parse` validates at runtime; without it, `T` is the caller's
+        // unchecked assertion of the response shape (the usual HTTP boundary).
+        return options.parse ? options.parse(data) : data;
+    }
+}
+/** Default same-origin client. Configure your own via `new HttpClient({ … })`. */
+export const http = new HttpClient();

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-export { redirect, reload, replace, storage } from "./browser.js";
+export type { CookieOptions, PersistedSignalOptions, ShareData, StorageArea, WebStorageOptions, WindowSize, } from "./browser.js";
+export { back, clipboard, cookie, forward, hash, mediaQuery, navigate, online, persistedSignal, prefersDark, queryParam, redirect, reload, replace, session, share, storage, visibility, WebStorage, windowSize, } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
+export type { HttpClientOptions, HttpRequestOptions } from "./http.js";
+export { HttpClient, HttpError, http } from "./http.js";
 export { hydrate } from "./hydrate.js";
 export { batch, effect, isSignal, memo, onCleanup, type ReadSignal, type Signal, signal, untrack, } from "./reactive.js";
 export { type Disposer, render } from "./render.js";

package/dist/index.js

@@ -1,12 +1,7 @@
-// ─── Client surface (node-free — safe to bundle for the browser) ──────
-//
-// Server-only exports (AuroraManager, Pages, renderPage, serveAssets) that pull
-// node:fs / node:path / node:url live in `@c9up/aurora/server`. Keeping them off
-// this barrel is what lets a browser bundle import the client primitives without
-// the bundler dragging Node built-ins through the import graph.
-export { redirect, reload, replace, storage } from "./browser.js";
+export { back, clipboard, cookie, forward, hash, mediaQuery, navigate, online, persistedSignal, prefersDark, queryParam, redirect, reload, replace, session, share, storage, visibility, WebStorage, windowSize, } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
+export { HttpClient, HttpError, http } from "./http.js";
 export { hydrate } from "./hydrate.js";
 export { batch, effect, isSignal, memo, onCleanup, signal, untrack, } from "./reactive.js";
 export { render } from "./render.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Aurora — reactive UI runtime for the Ream framework. Tagged-template DOM, signal-based state, isomorphic SSR + hydration, zero build step.",
   "license": "MIT",
   "type": "module",