@barefootjs/hono 0.5.3 → 0.6.1

package/dist/render.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Framework-agnostic SSR render entry for the hono/jsx runtime.
+ *
+ * BarefootJS components compiled with the Hono adapter are plain
+ * `hono/jsx` components: they render to an HTML string without needing a
+ * Hono `app`, a router, or `hono/jsx-renderer`'s request context. This
+ * module exposes that capability directly so any HTTP framework (h3,
+ * Elysia, Express, …) can host BarefootJS by importing this package as a
+ * render runtime — the same way the Go `Echo` integration imports the
+ * framework-agnostic `bf` runtime shipped by the go-template adapter.
+ *
+ * Two entry points:
+ *   - `renderToHtml`   — buffered: resolves the whole tree to one string.
+ *   - `renderToStream` — streaming: returns a `ReadableStream` so
+ *                        `<Suspense>` boundaries flush out-of-order.
+ *
+ * Both accept a `hono/jsx` node (typically a full page including the
+ * layout shell, `<BfImportMap>`, and `<BfScripts>`).
+ */
+/**
+ * Render a hono/jsx node to a complete HTML string.
+ *
+ * A `hono/jsx` node stringifies via `.toString()`, which returns either
+ * a string (fully synchronous tree) or a `Promise<string>` (the tree
+ * contains an `async` component). We normalise both to `Promise<string>`
+ * so callers always `await` once. Streaming `<Suspense>` boundaries are
+ * NOT resolved here — use `renderToStream` when the page streams.
+ */
+export declare function renderToHtml(node: unknown): Promise<string>;
+/**
+ * Render a hono/jsx node to a `ReadableStream` of UTF-8 HTML chunks.
+ *
+ * Use this when the page contains `<Suspense>` boundaries (e.g. async
+ * data / streaming SSR): the shell flushes immediately and each boundary
+ * streams in as it resolves. The returned stream is a Web-standard
+ * `ReadableStream`, directly returnable from any WinterCG-compatible
+ * handler (h3, Elysia, Hono, Workers, …).
+ */
+export declare function renderToStream(node: unknown): ReadableStream;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAGjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,CAE5D"}

package/dist/render.js

@@ -0,0 +1,13 @@
+// src/render.ts
+import { renderToReadableStream } from "hono/jsx/streaming";
+async function renderToHtml(node) {
+  const out = node.toString();
+  return out instanceof Promise ? await out : out;
+}
+function renderToStream(node) {
+  return renderToReadableStream(node);
+}
+export {
+  renderToStream,
+  renderToHtml
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/hono",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "description": "Hono integration for BarefootJS",
   "type": "module",
   "main": "./dist/index.js",
@@ -72,6 +72,10 @@
     "./app": {
       "types": "./dist/app.d.ts",
       "import": "./dist/app.js"
+    },
+    "./render": {
+      "types": "./dist/render.d.ts",
+      "import": "./dist/render.js"
     }
   },
   "files": [
@@ -80,7 +84,7 @@
   ],
   "scripts": {
     "build": "bun run build:js && bun run build:types",
-    "build:js": "bun build ./src/index.ts ./src/adapter/index.ts ./src/scripts.tsx ./src/portals.tsx ./src/portal-ssr.tsx ./src/dialog-context.tsx ./src/client-shim.ts ./src/preload.tsx ./src/dev.tsx ./src/dev-worker.ts ./src/jsx/jsx-runtime/index.ts ./src/jsx/jsx-dev-runtime/index.ts ./src/async.tsx ./src/utils.ts ./src/build.ts ./src/app.ts --root ./src --outdir ./dist --format esm --external hono --external @barefootjs/client --external @barefootjs/jsx --external @barefootjs/shared",
+    "build:js": "bun build ./src/index.ts ./src/adapter/index.ts ./src/scripts.tsx ./src/portals.tsx ./src/portal-ssr.tsx ./src/dialog-context.tsx ./src/client-shim.ts ./src/preload.tsx ./src/dev.tsx ./src/dev-worker.ts ./src/jsx/jsx-runtime/index.ts ./src/jsx/jsx-dev-runtime/index.ts ./src/async.tsx ./src/utils.ts ./src/build.ts ./src/app.ts ./src/render.ts --root ./src --outdir ./dist --format esm --external hono --external @barefootjs/client --external @barefootjs/jsx --external @barefootjs/shared",
     "build:types": "tsgo --emitDeclarationOnly --outDir ./dist",
     "test": "bun test",
     "clean": "rm -rf dist",

package/src/render.ts

@@ -0,0 +1,48 @@
+/**
+ * Framework-agnostic SSR render entry for the hono/jsx runtime.
+ *
+ * BarefootJS components compiled with the Hono adapter are plain
+ * `hono/jsx` components: they render to an HTML string without needing a
+ * Hono `app`, a router, or `hono/jsx-renderer`'s request context. This
+ * module exposes that capability directly so any HTTP framework (h3,
+ * Elysia, Express, …) can host BarefootJS by importing this package as a
+ * render runtime — the same way the Go `Echo` integration imports the
+ * framework-agnostic `bf` runtime shipped by the go-template adapter.
+ *
+ * Two entry points:
+ *   - `renderToHtml`   — buffered: resolves the whole tree to one string.
+ *   - `renderToStream` — streaming: returns a `ReadableStream` so
+ *                        `<Suspense>` boundaries flush out-of-order.
+ *
+ * Both accept a `hono/jsx` node (typically a full page including the
+ * layout shell, `<BfImportMap>`, and `<BfScripts>`).
+ */
+
+import { renderToReadableStream } from 'hono/jsx/streaming'
+
+/**
+ * Render a hono/jsx node to a complete HTML string.
+ *
+ * A `hono/jsx` node stringifies via `.toString()`, which returns either
+ * a string (fully synchronous tree) or a `Promise<string>` (the tree
+ * contains an `async` component). We normalise both to `Promise<string>`
+ * so callers always `await` once. Streaming `<Suspense>` boundaries are
+ * NOT resolved here — use `renderToStream` when the page streams.
+ */
+export async function renderToHtml(node: unknown): Promise<string> {
+  const out = (node as { toString(): string | Promise<string> }).toString()
+  return out instanceof Promise ? await out : out
+}
+
+/**
+ * Render a hono/jsx node to a `ReadableStream` of UTF-8 HTML chunks.
+ *
+ * Use this when the page contains `<Suspense>` boundaries (e.g. async
+ * data / streaming SSR): the shell flushes immediately and each boundary
+ * streams in as it resolves. The returned stream is a Web-standard
+ * `ReadableStream`, directly returnable from any WinterCG-compatible
+ * handler (h3, Elysia, Hono, Workers, …).
+ */
+export function renderToStream(node: unknown): ReadableStream {
+  return renderToReadableStream(node as Parameters<typeof renderToReadableStream>[0])
+}