@jk2908/solas 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.12.0
+
+### Features
+
+- The static adapter supports client-side navigation. The build emits each fully prerendered route's RSC payload as `<route>.rsc.txt` next to its HTML, and the browser router fetches it, so a static host needs no server to answer navigations.
+- The active adapter's name is exposed as `import.meta.env.SOLAS_ADAPTER`, so apps can branch on the platform.
+
+## 0.11.1
+
+### Fixes
+
+- A document request is now served as HTML by default. Solas only returns the RSC payload when the client asks for `text/x-component` (and not `text/html`); a request to a page without that, such as `Accept: */*` or no `Accept` header, used to receive the RSC payload — and, for a page with no endpoint, an error.
+
 ## 0.11.0
 
 ### Breaking

package/README.md

@@ -229,6 +229,8 @@ Solas resolves the origin in this order:
 
 The resolved origin is exposed to your app as `import.meta.env.VITE_APP_URL` and is used for build-time prerender requests and `sitemap` URLs. When `url` is set, it is also used as a trusted origin for CSRF.
 
+The active adapter's name is exposed as `import.meta.env.SOLAS_ADAPTER`, so your app can branch on the platform it is deployed to.
+
 You usually only need `url` in production, where the Vite dev server origin is meaningless. For example, to generate a `sitemap.xml` with real URLs:
 
 ```ts
@@ -707,7 +709,9 @@ export default defineConfig({
 })
 ```
 
-`vite build` writes the site to `build/` (override with `outDir`): the client assets, each route as `<route>.html` (or `<route>/index.html` under `trailingSlash: 'always'`), plus `sitemap.xml` and `robots.txt`. Serve that directory with anything — `npx serve build`, GitHub Pages, Netlify, an S3 bucket, nginx.
+`vite build` writes the site to `build/` (override with `outDir`): the client assets, each route as `<route>.html` (or `<route>/index.html` under `trailingSlash: 'always'`), its RSC payload as `<route>.rsc.txt`, plus `sitemap.xml` and `robots.txt`. Serve that directory with anything — `npx serve build`, GitHub Pages, Netlify, an S3 bucket, nginx.
+
+Client-side navigation works with no server: the browser router fetches each route's `<route>.rsc.txt` payload instead of asking a server for `text/x-component`.
 
 Because it forces full prerendering, routes that need a server are not a fit: per-route PPR or SSR opt-ins and dynamic routes without `params()`.
 

package/dist/index.js

@@ -261,6 +261,7 @@ function solas(c) {
             viteConfig.define ??= {};
             viteConfig.define['import.meta.env.VITE_APP_URL'] = JSON.stringify(resolvedUrl);
             viteConfig.define['import.meta.env.SOLAS_VERSION'] = JSON.stringify(pkg.version);
+            viteConfig.define['import.meta.env.SOLAS_ADAPTER'] = JSON.stringify(config.adapter?.name ?? '');
             viteConfig.optimizeDeps ??= {};
             viteConfig.optimizeDeps.exclude = [
                 ...new Set([
@@ -335,6 +336,7 @@ function solas(c) {
                 precompress: config.precompress,
                 trailingSlash: config.trailingSlash,
                 url: resolvedUrl,
+                adapter: config.adapter?.name ?? '',
             }));
         },
         buildApp: {

package/dist/internal/browser-router/router.js

@@ -28,6 +28,25 @@ const DEFAULT_GO_CONFIG = {
 };
 const logger = new Logger();
 const responseCache = new ResponseCache();
+const STATIC = import.meta.env.SOLAS_ADAPTER === 'static';
+/**
+ * The URL to fetch the response for a navigation. On a static host that is the
+ * pre-generated RSC payload; otherwise the path itself carries the RSC response
+ * for an `Accept: text/x-component` request.
+ */
+function getPayloadUrl(path) {
+    const url = new URL(path, window.location.origin);
+    url.pathname = url.pathname.endsWith('/')
+        ? `${url.pathname}index.rsc.txt`
+        : `${url.pathname}.rsc.txt`;
+    url.search = '';
+    return url;
+}
+function performNavigationFetch(path, init) {
+    return STATIC
+        ? fetch(getPayloadUrl(path), init)
+        : fetch(path, { ...init, headers: { ...init?.headers, accept: 'text/x-component' } });
+}
 export function BrowserRouterProvider({ children, setPayload, isNavigating = false, url, }) {
     const id = useRef(0);
     const controller = useRef(null);
@@ -79,10 +98,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             if (!promise) {
                 const ctrl = new AbortController();
                 controller.current = ctrl;
-                promise = fetch(path, {
-                    headers: { accept: 'text/x-component' },
-                    signal: ctrl.signal,
-                });
+                promise = performNavigationFetch(path, { signal: ctrl.signal });
                 responseCache.set(path, promise);
             }
             if (navigationId !== id.current)
@@ -91,7 +107,11 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
                 promise,
                 createFromFetch(promise),
             ]);
-            const resolvedPath = ResponseCache.toCacheKey(res.url, window.location.origin) ?? path;
+            // on a static host the payload comes from `<path>.rsc.txt`, so the
+            // response URL is not the page path
+            const resolvedPath = STATIC
+                ? path
+                : (ResponseCache.toCacheKey(res.url, window.location.origin) ?? path);
             if (navigationId !== id.current)
                 return resolvedPath;
             if (resolvedPath !== path) {
@@ -136,7 +156,7 @@ export function BrowserRouterProvider({ children, setPayload, isNavigating = fal
             return;
         if (responseCache.has(key))
             return;
-        responseCache.set(key, fetch(key, { headers: { Accept: 'text/x-component' } }));
+        responseCache.set(key, performNavigationFetch(key));
     }, []);
     /**
      * Refreshes the current page by re-fetching the RSC response for the current path and updating the

package/dist/internal/env/rsc.js

@@ -6,7 +6,7 @@ import * as Config from '../../config.js';
 import * as RuntimeManifest from '../../manifest.js';
 import { createHttpRouter } from '../http-router/create-http-router.js';
 import { HttpRouter } from '../http-router/router.js';
-import { normaliseTrailingSlash } from '../http-router/utils.js';
+import { isRscRequest, normaliseTrailingSlash } from '../http-router/utils.js';
 import { Metadata } from '../metadata.js';
 import { HttpException, isHttpException, toHttpException, toHttpExceptionLike, } from '../navigation/http-exception.js';
 import { isRedirect, toRedirect } from '../navigation/redirect.js';
@@ -190,7 +190,7 @@ export function createHandler(config, manifest, importMap, options = {}) {
         }
         const { stream: rscStream, status, ppr, } = await createPayload(req, manifest, importMap, config.metadata, opts.returnValue, opts.formState, opts.temporaryReferences);
         const stream = await rscStream;
-        if (!req.headers.get('accept')?.includes('text/html')) {
+        if (isRscRequest(req)) {
             return new Response(stream, {
                 headers: {
                     'Cache-Control': 'private, no-store',
@@ -338,14 +338,13 @@ export function createHandler(config, manifest, importMap, options = {}) {
     /**
      * Serve the saved HTML for a fully prerendered route. Runs as the route
      * handler, after middleware, so middleware applies to static routes too. It
-     * returns null for anything else (a route without a saved prerender, an RSC
-     * navigation, or a request without an HTML accept header), so the caller
-     * falls back to rendering.
+     * returns null for anything else (a route without a saved prerender or an RSC
+     * navigation), so the caller falls back to rendering.
      */
     async function serveFullPrerender(req) {
         if (import.meta.env.DEV)
             return null;
-        if (!(req.headers.get('accept') ?? '').includes('text/html'))
+        if (isRscRequest(req))
             return null;
         if (req.headers.get(`x-${Config.SLUG}-prerender-artifact`) === '1')
             return null;

package/dist/internal/http-router/create-http-router.js

@@ -1,4 +1,5 @@
 import { HttpRouter } from './router.js';
+import { isRscRequest } from './utils.js';
 function callEndpoint(fn, req) {
     // endpoint modules may export either a zero-arg handler or one that expects the request
     if (fn.length === 0)
@@ -82,12 +83,12 @@ export function createHttpRouter(config, manifest, importMap, rsc, serveFullPrer
         const middlewares = mergeMiddlewares(importMap[page.__id]?.middlewares, endpointEntry ? importMap[endpointEntry.__id]?.middlewares : undefined);
         router.add(page.__path, 'GET', async req => {
             const accept = req.headers.get('accept') ?? '';
-            if (accept.includes('text/html') || accept.includes('text/x-component')) {
+            // a request that asks for a document or the RSC payload is rendered,
+            // as is any request to a page with no endpoint; anything else is the
+            // endpoint's own body
+            if (isRscRequest(req) || accept.includes('text/html') || !endpoint) {
                 return (await serveFullPrerender?.(req)) ?? rsc(req);
             }
-            if (!endpoint) {
-                throw new Error(`Missing unified endpoint handler for ${page.__path}`);
-            }
             return callEndpoint(endpoint, req);
         }, page.__params, middlewares);
     }

package/dist/internal/http-router/utils.d.ts

@@ -1,4 +1,12 @@
 import type { PluginConfig } from '../../types.js';
+/**
+ * Whether a request wants the RSC payload rather than a document.
+ *
+ * The client asks for `text/x-component` on navigations. Anything else (a
+ * browser, or a fetch with no explicit preference) should get HTML, so a plain
+ * request to a page never receives the RSC payload.
+ */
+export declare function isRscRequest(req: Request): boolean;
 export type PathPattern = {
     path: string;
     wildcardNames: Set<string>;

package/dist/internal/http-router/utils.js

@@ -1,3 +1,14 @@
+/**
+ * Whether a request wants the RSC payload rather than a document.
+ *
+ * The client asks for `text/x-component` on navigations. Anything else (a
+ * browser, or a fetch with no explicit preference) should get HTML, so a plain
+ * request to a page never receives the RSC payload.
+ */
+export function isRscRequest(req) {
+    const accept = req.headers.get('accept') ?? '';
+    return accept.includes('text/x-component') && !accept.includes('text/html');
+}
 /**
  * Escape a literal path segment so it can be used safely in a
  * path-to-regexp pattern.

package/dist/internal/postbuild.js

@@ -114,6 +114,14 @@ export async function postbuild(cwd = process.cwd()) {
                     const staticPath = path.join(staticRoot, Prerender.staticRoutePath(route, staticMode));
                     await fs.mkdir(path.dirname(staticPath), { recursive: true });
                     await fs.writeFile(staticPath, artifact.html);
+                    // a static host has no server to answer an RSC navigation, so emit
+                    // the payload next to the HTML for the client router to fetch
+                    if (manifest.adapter === 'static') {
+                        await fs.writeFile(staticPath.replace(/\.html$/, '.rsc.txt'), await Prerender.getRscPayload(app, route, {
+                            origin: manifest.url,
+                            base: manifest.base,
+                        }));
+                    }
                     artfifactManifest[route] = {
                         mode: artifact.mode,
                         files: ['html'],

package/dist/internal/prerender.d.ts

@@ -122,6 +122,17 @@ export declare function get(app: {
     route: string;
     artifact: any;
 }>;
+/**
+ * Fetch the RSC payload for a route, the response a client would get for an RSC
+ * navigation. Written alongside a fully prerendered route's HTML so a static
+ * host can serve client-side navigation without a server.
+ */
+export declare function getRscPayload(app: {
+    fetch: (req: Request) => Promise<Response>;
+}, route: string, opts: {
+    origin?: string;
+    base?: string;
+}): Promise<string>;
 /**
  * Run the prerendering process for a list of routes with a specified concurrency limit,
  * by calling the 'get' function for each route and yielding the results as they become available.

package/dist/internal/prerender.js

@@ -331,6 +331,19 @@ export async function get(app, route, opts) {
         return { route, status: res.status };
     return { route, artifact: await res.json() };
 }
+/**
+ * Fetch the RSC payload for a route, the response a client would get for an RSC
+ * navigation. Written alongside a fully prerendered route's HTML so a static
+ * host can serve client-side navigation without a server.
+ */
+export async function getRscPayload(app, route, opts) {
+    const url = `${opts.origin ?? `http://${Config.SLUG}.local`}${applyBasePath(route, opts.base)}`;
+    const res = await app.fetch(new Request(url, { headers: { Accept: 'text/x-component' } }));
+    if (!(res instanceof Response) || !res.ok) {
+        throw new Error(`[prerender] RSC payload for ${route} was not served`);
+    }
+    return res.text();
+}
 /**
  * Run the prerendering process for a list of routes with a specified concurrency limit,
  * by calling the 'get' function for each route and yielding the results as they become available.

package/dist/types.d.ts

@@ -130,6 +130,7 @@ export type BuildManifest = {
     precompress: boolean;
     trailingSlash: (typeof Config.TRAILING_SLASH_MODES)[number];
     url?: string;
+    adapter?: string;
 };
 export declare namespace Route {
     type ParamsOf<TRoute> = TRoute extends {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.11.0",
+	"version": "0.12.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",