@c9up/aurora 0.1.5 → 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/dist/reactive.d.ts

@@ -28,6 +28,13 @@ export interface Signal<T> {
  * sites need to import this directly.
  */
 export declare const SIGNAL_BRAND: unique symbol;
+/**
+ * @internal Swap the ambient owner, returning the previous one so the
+ * caller can restore it. `component()` uses this to own the effects and
+ * memos a setup function creates, so they dispose at unmount instead of
+ * keeping their signal subscriptions alive forever.
+ */
+export declare function setOwner(owner: Array<() => void> | undefined): Array<() => void> | undefined;
 /**
  * Create a writable signal seeded with `initial`. Reads register the
  * current observer; writes notify every observer that previously read.

package/dist/reactive.js

@@ -23,6 +23,24 @@ const pendingNotifications = new Set();
 function activeObserver() {
     return observerStack[observerStack.length - 1];
 }
+/**
+ * Ambient disposal owner. A non-reactive scope (e.g. a component's setup
+ * run) registers an array here so effects/memos created during its
+ * execution push their disposer into it and are torn down when the scope
+ * ends. `undefined` at top level — no scope, no auto-disposal.
+ */
+let currentOwner;
+/**
+ * @internal Swap the ambient owner, returning the previous one so the
+ * caller can restore it. `component()` uses this to own the effects and
+ * memos a setup function creates, so they dispose at unmount instead of
+ * keeping their signal subscriptions alive forever.
+ */
+export function setOwner(owner) {
+    const prev = currentOwner;
+    currentOwner = owner;
+    return prev;
+}
 /**
  * Create a writable signal seeded with `initial`. Reads register the
  * current observer; writes notify every observer that previously read.
@@ -129,7 +147,13 @@ export function effect(fn) {
         },
     };
     eff.run();
-    return () => eff.dispose();
+    const dispose = () => eff.dispose();
+    // Register with the ambient owner (e.g. a component's setup scope) so the
+    // effect is torn down when that scope ends. `memo()` builds on this — its
+    // internal recompute effect inherits the same ownership, which is what
+    // stops a memo created in component setup from leaking after unmount.
+    currentOwner?.push(dispose);
+    return dispose;
 }
 /**
  * Register a cleanup callback against the currently-running effect.

package/dist/relay.js

@@ -21,7 +21,6 @@ const STATE = {
     sse: null,
     uid: null,
     channels: new Map(),
-    pending: [],
 };
 let CONFIG = {
     sseUrl: "/__relay/events",
@@ -60,17 +59,15 @@ const CLIENT = {
         }
         const adapted = handler;
         handlers.add(adapted);
-        // Subscribe over POST as soon as we have a uid. If the SSE is
-        // still mid-handshake, queue the call and flush on `connected`.
-        const doSubscribe = () => {
+        // Subscribe over POST as soon as we have a uid. Before the first uid (or
+        // during an auto-reconnect) the channel already lives in STATE.channels
+        // and is (re-)subscribed by the `connected` handler — so the server,
+        // which assigns a fresh uid per connection, always learns every channel.
+        if (STATE.uid) {
             postSubscribe(channel).catch((err) => {
                 console.warn(`[aurora/relay] subscribe to ${channel} failed:`, err);
             });
-        };
-        if (STATE.uid)
-            doSubscribe();
-        else
-            STATE.pending.push(doSubscribe);
+        }
         // Detacher — only removes the local listener. The server-side
         // subscription stays open; closing it would interrupt other
         // listeners on the same channel.
@@ -85,7 +82,6 @@ const CLIENT = {
         }
         STATE.uid = null;
         STATE.channels.clear();
-        STATE.pending.length = 0;
     },
 };
 function open() {
@@ -95,9 +91,16 @@ function open() {
         const data = safeJson(ev.data);
         if (data && typeof data.uid === "string") {
             STATE.uid = data.uid;
-            const queue = STATE.pending.splice(0);
-            for (const fn of queue)
-                fn();
+            // Re-apply EVERY active subscription on each (re)connect. The server
+            // assigns a fresh uid per connection and has no memory of prior
+            // subscriptions, so both the first connect AND browser auto-reconnects
+            // must re-POST every live channel — otherwise the client silently
+            // stops receiving after a reconnect.
+            for (const channel of STATE.channels.keys()) {
+                postSubscribe(channel).catch((err) => {
+                    console.warn(`[aurora/relay] re-subscribe to ${channel} failed:`, err);
+                });
+            }
         }
     });
     sse.onmessage = (ev) => {

package/dist/server/renderPage.js

@@ -41,7 +41,7 @@ export async function renderPage(ctx, pages, name, props, options = {}) {
 <head>
 <meta charset="utf-8" />
 <meta name="viewport" content="width=device-width,initial-scale=1" />
-<script type="importmap">${JSON.stringify({ imports: importmap })}</script>
+<script type="importmap">${escapeJsonForScript({ imports: importmap })}</script>
 ${options.headExtra ?? ""}
 </head>
 <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.5",
+  "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",