hono-preact 0.2.0 → 0.4.0

package/dist/server/sse.js

@@ -1,130 +1,155 @@
-import { streamSSE } from 'hono/streaming';
 import { fanStart, fanChunk, fanEnd, fanError, fanAbort, } from '../iso/internal.js';
+function sseEncodeTransform() {
+    const encoder = new TextEncoder();
+    return new TransformStream({
+        transform(frame, controller) {
+            const lines = [];
+            if (frame.event)
+                lines.push(`event: ${frame.event}`);
+            if (frame.id)
+                lines.push(`id: ${frame.id}`);
+            lines.push(`data: ${frame.data}`);
+            controller.enqueue(encoder.encode(lines.join('\n') + '\n\n'));
+        },
+    });
+}
+function isTimeoutAbort(signal) {
+    return Boolean(signal?.aborted &&
+        signal.reason instanceof DOMException &&
+        signal.reason.name === 'TimeoutError');
+}
 function encodeErrorPayload(err) {
     const message = err instanceof Error ? err.message : String(err);
     const name = err instanceof Error ? err.name : 'Error';
     return JSON.stringify({ message, name });
 }
 /**
- * Wrap an async generator as an SSE response.
- *
- * Each yield is JSON-encoded and written as a `data:` event.
- * If `emitResult` is true and the generator's return value is defined,
- * it is written as `event: result\ndata: <json>` before the stream closes.
- * If the generator throws, an `event: error\ndata: {"message","name"}` frame
- * is written and the stream closes cleanly (Hono's default error handler is
- * never invoked because we catch inside the callback).
+ * Adapt a `ReadableStream<T>` as an async generator (with no return value).
+ * The reader is released in `finally`, which fires either when the consumer
+ * stops iterating or when the source is exhausted.
+ */
+async function* iterReadable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            yield value;
+        }
+    }
+    finally {
+        reader.cancel().catch(() => undefined);
+    }
+}
+/**
+ * The shared pump implementation. Iterates `source` (a generator that may
+ * return a final value), encodes each yielded value as a JSON `data:` frame,
+ * runs the observer lifecycle, and translates errors into `event: error` or
+ * `event: timeout` frames.
  *
- * When `observers` is provided, the pump fires the corresponding lifecycle
- * hooks (`onStart` / `onChunk` / `onEnd` / `onError` / `onAbort`) so
- * users can attach instrumentation via `defineStreamObserver(...)`.
+ * Observer state (`chunks`, `started`, `finished`) lives in the outer
+ * function scope so the outer ReadableStream's `cancel()` callback can fire
+ * `onAbort` when the consumer cancels mid-stream.
  */
-export function sseGeneratorResponse(c, gen, options = {}) {
-    const { emitResult = false, observers, observerCtx } = options;
+function buildSseResponse(source, options) {
+    const { emitResult = false, observers, observerCtx, signal, timeoutMs, } = options;
     const obs = observers ?? [];
-    return streamSSE(c, async (stream) => {
-        let chunks = 0;
-        let started = false;
+    let chunks = 0;
+    let started = false;
+    let finished = false;
+    async function* framePump() {
         if (obs.length > 0 && observerCtx) {
             fanStart(obs, observerCtx);
             started = true;
         }
         try {
-            while (!stream.aborted) {
-                const step = await gen.next();
+            while (true) {
+                const step = await source.next();
                 if (step.done) {
                     if (emitResult && step.value !== undefined) {
-                        await stream.writeSSE({
-                            event: 'result',
-                            data: JSON.stringify(step.value),
-                        });
+                        yield { event: 'result', data: JSON.stringify(step.value) };
                     }
                     if (started && observerCtx) {
                         fanEnd(obs, observerCtx, { chunks, result: step.value });
                     }
+                    finished = true;
                     return;
                 }
-                await stream.writeSSE({ data: JSON.stringify(step.value) });
+                yield { data: JSON.stringify(step.value) };
                 if (started && observerCtx) {
                     fanChunk(obs, observerCtx, step.value, chunks);
                 }
                 chunks += 1;
             }
-            // Loop exited because the response stream was aborted (typically a
-            // client disconnect). Release the generator and notify observers.
-            await gen.return(undefined).catch(() => {
-                /* swallow */
-            });
-            if (started && observerCtx) {
-                fanAbort(obs, observerCtx, { chunks });
-            }
         }
         catch (err) {
-            await gen.return(undefined).catch(() => {
-                /* swallow */
-            });
+            await source.return(undefined).catch(() => undefined);
             if (started && observerCtx) {
                 fanError(obs, observerCtx, err, { chunks });
             }
-            await stream.writeSSE({
-                event: 'error',
-                data: encodeErrorPayload(err),
-            });
+            if (isTimeoutAbort(signal) && typeof timeoutMs === 'number') {
+                yield { event: 'timeout', data: JSON.stringify({ timeoutMs }) };
+            }
+            else {
+                yield { event: 'error', data: encodeErrorPayload(err) };
+            }
+            finished = true;
         }
+    }
+    const pump = framePump();
+    const body = new ReadableStream({
+        async pull(controller) {
+            const { value, done } = await pump.next();
+            if (done) {
+                controller.close();
+            }
+            else {
+                controller.enqueue(value);
+            }
+        },
+        cancel() {
+            // Consumer cancelled before the pump completed. Notify observers via
+            // `onAbort` exactly when we've genuinely been aborted mid-stream
+            // (i.e. the source started but didn't finish naturally).
+            if (!finished && started && observerCtx) {
+                fanAbort(obs, observerCtx, { chunks });
+            }
+            pump.return(undefined).catch(() => undefined);
+            source.return(undefined).catch(() => undefined);
+        },
+    }).pipeThrough(sseEncodeTransform());
+    return new Response(body, {
+        headers: {
+            'content-type': 'text/event-stream',
+            'cache-control': 'no-cache',
+        },
     });
 }
 /**
- * Wrap a ReadableStream<T> (with T a JSON-encodable value) as an SSE response.
- * Each enqueued chunk is JSON-encoded and written as a `data:` event.
+ * Wrap an async generator as an SSE response.
  *
- * Observer fanout mirrors `sseGeneratorResponse`: `onStart` fires before the
- * first read, `onChunk` per chunk, `onEnd` on normal completion, `onError` on
- * throw, `onAbort` when the response stream is aborted.
+ * Each yield is JSON-encoded and written as a `data:` event. If `emitResult`
+ * is true and the generator's return value is defined, it is written as
+ * `event: result\ndata: <json>` before the stream closes. If the generator
+ * throws, an `event: error` or `event: timeout` frame is written and the
+ * stream closes cleanly. Observer lifecycle hooks (`onStart` / `onChunk` /
+ * `onEnd` / `onError` / `onAbort`) fire from inside the pump.
  */
-export function sseReadableStreamResponse(c, source, options = {}) {
-    const { observers, observerCtx } = options;
-    const obs = observers ?? [];
-    return streamSSE(c, async (stream) => {
-        const reader = source.getReader();
-        let chunks = 0;
-        let started = false;
-        if (obs.length > 0 && observerCtx) {
-            fanStart(obs, observerCtx);
-            started = true;
-        }
-        try {
-            while (!stream.aborted) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    if (started && observerCtx) {
-                        fanEnd(obs, observerCtx, { chunks, result: undefined });
-                    }
-                    return;
-                }
-                await stream.writeSSE({ data: JSON.stringify(value) });
-                if (started && observerCtx) {
-                    fanChunk(obs, observerCtx, value, chunks);
-                }
-                chunks += 1;
-            }
-            if (started && observerCtx) {
-                fanAbort(obs, observerCtx, { chunks });
-            }
-        }
-        catch (err) {
-            if (started && observerCtx) {
-                fanError(obs, observerCtx, err, { chunks });
-            }
-            await stream.writeSSE({
-                event: 'error',
-                data: encodeErrorPayload(err),
-            });
-        }
-        finally {
-            reader.cancel().catch(() => {
-                /* swallow */
-            });
-        }
+export function sseGeneratorResponse(_c, gen, options = {}) {
+    return buildSseResponse(gen, options);
+}
+/**
+ * Wrap a `ReadableStream<T>` (with `T` a JSON-encodable value) as an SSE
+ * response. Each enqueued chunk is JSON-encoded and written as a `data:`
+ * event. Observer lifecycle hooks fire identically to `sseGeneratorResponse`;
+ * `emitResult` is not meaningful here (streams have no return value) and is
+ * ignored.
+ */
+export function sseReadableStreamResponse(_c, source, options = {}) {
+    return buildSseResponse(iterReadable(source), {
+        ...options,
+        emitResult: false,
     });
 }
 export function isAsyncGenerator(value) {

package/dist/vite/client-entry.js

@@ -2,14 +2,23 @@ import * as path from 'node:path';
 export const VIRTUAL_CLIENT_ENTRY_ID = 'virtual:hono-preact/client';
 const RESOLVED_ID = '\0' + VIRTUAL_CLIENT_ENTRY_ID;
 export function generateClientEntrySource(opts) {
-    return (`import { h, hydrate } from 'preact';\n` +
+    return (`import { h, hydrate, render as renderPreact } from 'preact';\n` +
         `import { LocationProvider } from 'preact-iso';\n` +
-        `import { Routes } from 'hono-preact';\n` +
-        `import { __dispatchRouteChange, installStreamRegistry } from 'hono-preact/internal';\n` +
+        `import { Routes, PersistHost } from 'hono-preact';\n` +
+        `import { __dispatchRouteChange, installStreamRegistry, installHistoryShim } from 'hono-preact/internal';\n` +
         `import routes from '${opts.routesAbsPath}';\n` +
         `\n` +
+        `installHistoryShim();\n` +
         `installStreamRegistry();\n` +
         `\n` +
+        `let persistHost = document.getElementById('__hp_persist_root');\n` +
+        `if (!persistHost) {\n` +
+        `  persistHost = document.createElement('div');\n` +
+        `  persistHost.id = '__hp_persist_root';\n` +
+        `  document.body.appendChild(persistHost);\n` +
+        `}\n` +
+        `renderPreact(h(PersistHost, null), persistHost);\n` +
+        `\n` +
         `let lastPath;\n` +
         `function onRouteChange(path) {\n` +
         `  const from = lastPath;\n` +

package/dist/vite/server-entry.js

@@ -22,9 +22,10 @@ export function generateCoreAppModule(opts) {
         `import { LocationProvider } from 'preact-iso';\n` +
         `import { Routes, env } from 'hono-preact';\n` +
         `import {\n` +
-        `  actionsHandler,\n` +
         `  loadersHandler,\n` +
+        `  makePageActionResolvers,\n` +
         `  makePageUseResolvers,\n` +
+        `  pageActionHandler,\n` +
         `  renderPage,\n` +
         `  routeServerModules,\n` +
         `} from 'hono-preact/server';\n` +
@@ -37,11 +38,18 @@ export function generateCoreAppModule(opts) {
         `const dev = import.meta.env.DEV;\n` +
         `const serverModules = routeServerModules(routes);\n` +
         `const pageUseResolvers = makePageUseResolvers(routes.serverRoutes, { dev });\n` +
+        `const pageActionResolvers = makePageActionResolvers(routes.serverRoutes, { dev });\n` +
         `\n` +
         `export const app = new Hono()\n` +
         apiMount +
         `  .post('/__loaders', loadersHandler(serverModules, { dev, appConfig, resolvePageUse: pageUseResolvers.byPath }))\n` +
-        `  .post('/__actions', actionsHandler(serverModules, { dev, appConfig, resolvePageUse: pageUseResolvers.byModuleKey }))\n` +
+        `  .post('*', pageActionHandler({\n` +
+        `    resolverByPath: pageActionResolvers.byPath,\n` +
+        `    resolvePageUseByPath: pageUseResolvers.byPath,\n` +
+        `    renderPage,\n` +
+        `    resolvePageNode: () => h(Layout, null, h(LocationProvider, null, h(Routes, { routes }))),\n` +
+        `    appConfig,\n` +
+        `  }))\n` +
         `  .get('*', (c) => renderPage(c, h(Layout, null, h(LocationProvider, null, h(Routes, { routes }))), { appConfig }));\n` +
         `\n` +
         `export default app;\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono-preact",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Hono on the edge, Preact in the browser, manifest driven routes, typed RPC, streaming everywhere.",
   "keywords": [
     "hono",
@@ -95,8 +95,8 @@
   },
   "devDependencies": {
     "typescript": "*",
-    "@hono-preact/iso": "0.1.0",
     "@hono-preact/server": "0.1.0",
+    "@hono-preact/iso": "0.1.0",
     "@hono-preact/vite": "0.1.0"
   },
   "scripts": {