react-bun-ssr 0.1.1 → 0.3.0

package/framework/runtime/client-transition-core.ts

@@ -0,0 +1,159 @@
+import { matchRouteBySegments } from "./matcher";
+import type {
+  ClientRouteSnapshot,
+  Params,
+  TransitionChunk,
+  TransitionDeferredChunk,
+  TransitionDocumentChunk,
+  TransitionInitialChunk,
+  TransitionRedirectChunk,
+} from "./types";
+
+export const PREFETCH_TTL_MS = 30_000;
+export const MAX_REDIRECT_DEPTH = 8;
+
+export interface TransitionChunkParserState {
+  buffer: string;
+  initialChunk: TransitionInitialChunk | TransitionRedirectChunk | TransitionDocumentChunk | null;
+  deferredChunks: TransitionDeferredChunk[];
+}
+
+export interface TransitionNavigationOptions {
+  historyManagedByNavigationApi?: boolean;
+  isPopState?: boolean;
+}
+
+export function createTransitionChunkParserState(): TransitionChunkParserState {
+  return {
+    buffer: "",
+    initialChunk: null,
+    deferredChunks: [],
+  };
+}
+
+export function matchClientPageRoute(
+  routes: ClientRouteSnapshot[],
+  pathname: string,
+): { route: ClientRouteSnapshot; params: Params } | null {
+  return matchRouteBySegments(routes, pathname);
+}
+
+function applyParsedTransitionChunk(
+  state: TransitionChunkParserState,
+  chunk: TransitionChunk,
+): TransitionChunkParserState {
+  if (chunk.type === "initial" || chunk.type === "redirect" || chunk.type === "document") {
+    if (state.initialChunk) {
+      return state;
+    }
+
+    return {
+      ...state,
+      initialChunk: chunk,
+    };
+  }
+
+  return {
+    ...state,
+    deferredChunks: [...state.deferredChunks, chunk],
+  };
+}
+
+export function consumeTransitionChunkText(
+  state: TransitionChunkParserState,
+  text: string,
+): TransitionChunkParserState {
+  let buffer = state.buffer + text;
+  let nextState = {
+    ...state,
+    buffer: "",
+  };
+
+  let start = 0;
+  for (let index = 0; index < buffer.length; index += 1) {
+    if (buffer[index] !== "\n") {
+      continue;
+    }
+
+    const line = buffer.slice(start, index).trim();
+    if (line.length > 0) {
+      nextState = applyParsedTransitionChunk(
+        nextState,
+        JSON.parse(line) as TransitionChunk,
+      );
+    }
+    start = index + 1;
+  }
+
+  buffer = buffer.slice(start);
+  return {
+    ...nextState,
+    buffer,
+  };
+}
+
+export function flushTransitionChunkText(
+  state: TransitionChunkParserState,
+): TransitionChunkParserState {
+  const trailing = state.buffer.trim();
+  if (trailing.length === 0) {
+    return {
+      ...state,
+      buffer: "",
+    };
+  }
+
+  return {
+    ...applyParsedTransitionChunk(
+      {
+        ...state,
+        buffer: "",
+      },
+      JSON.parse(trailing) as TransitionChunk,
+    ),
+    buffer: "",
+  };
+}
+
+export function sanitizePrefetchCache<T extends { createdAt: number }>(
+  cache: Map<string, T>,
+  options: {
+    now?: number;
+    ttlMs?: number;
+  } = {},
+): void {
+  const now = options.now ?? Date.now();
+  const ttlMs = options.ttlMs ?? PREFETCH_TTL_MS;
+
+  for (const [key, entry] of cache.entries()) {
+    if (now - entry.createdAt > ttlMs) {
+      cache.delete(key);
+    }
+  }
+}
+
+export function shouldSkipSoftNavigation(
+  currentPath: string,
+  targetPath: string,
+  options: TransitionNavigationOptions,
+): boolean {
+  return (
+    currentPath === targetPath
+    && !options.isPopState
+    && !options.historyManagedByNavigationApi
+  );
+}
+
+export function shouldHardNavigateForRedirectDepth(
+  depth: number,
+  maxDepth = MAX_REDIRECT_DEPTH,
+): boolean {
+  return depth > maxDepth;
+}
+
+export function isStaleNavigationToken(
+  activeToken: number,
+  candidateToken: number,
+): boolean {
+  return activeToken !== candidateToken;
+}

package/framework/runtime/config.ts

@@ -71,15 +71,20 @@ function toHeaderRules(config: FrameworkConfig): ResolvedResponseHeaderRule[] {
       throw new Error(`[rbssr config] \`headers[${index}].headers\` must include at least one header.`);
     }
 
-    const headers: Record<string, string> = {};
+    const headers: Record<string, string | null> = {};
     for (const [key, value] of entries) {
       if (typeof key !== "string" || key.trim().length === 0) {
         throw new Error(`[rbssr config] \`headers[${index}].headers\` contains an empty header name.`);
       }
 
+      if (value === null) {
+        headers[key] = null;
+        continue;
+      }
+
       if (typeof value !== "string" || value.trim().length === 0) {
         throw new Error(
-          `[rbssr config] \`headers[${index}].headers.${key}\` must be a non-empty string value.`,
+          `[rbssr config] \`headers[${index}].headers.${key}\` must be a non-empty string value or null.`,
         );
       }
 

package/framework/runtime/index.ts

@@ -26,5 +26,5 @@ export { createServer, startHttpServer } from "./server";
 export { defer, json, redirect, defineConfig } from "./helpers";
 export { isRouteErrorResponse, notFound, routeError } from "./route-errors";
 export { Link, type LinkProps } from "./link";
-export { useRouter, type Router, type RouterNavigateOptions } from "./router";
+export { useRouter, type Router, type RouterNavigateInfo, type RouterNavigateListener, type RouterNavigateOptions } from "./router";
 export { Outlet, useLoaderData, useParams, useRequestUrl, useRouteError } from "./tree";

package/framework/runtime/link.tsx

@@ -4,15 +4,7 @@ import type {
   MouseEvent,
   TouchEvent,
 } from "react";
-
-interface NavigateInfo {
-  from: string;
-  to: string;
-  status: number;
-  kind: "page" | "not_found" | "catch" | "error";
-  redirected: boolean;
-  prefetched: boolean;
-}
+import type { RouterNavigateInfo } from "./router";
 
 export interface LinkProps
   extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
@@ -20,7 +12,7 @@ export interface LinkProps
   replace?: boolean;
   scroll?: boolean;
   prefetch?: "intent" | "none";
-  onNavigate?: (info: NavigateInfo) => void;
+  onNavigate?: (info: RouterNavigateInfo) => void;
 }
 
 function shouldHandleNavigation(event: MouseEvent<HTMLAnchorElement>): boolean {
@@ -89,7 +81,7 @@ async function prefetch(href: string): Promise<void> {
 async function navigate(href: string, options: {
   replace?: boolean;
   scroll?: boolean;
-  onNavigate?: (info: NavigateInfo) => void;
+  onNavigate?: (info: RouterNavigateInfo) => void;
 }): Promise<void> {
   if (typeof window === "undefined") {
     return;

package/framework/runtime/markdown-routes.ts

@@ -112,24 +112,11 @@ function resolveGeneratedRoot(routesDir: string, generatedMarkdownRootDir?: stri
     return path.resolve(appRoutesMatch[1]!, ".rbssr", "generated", "markdown-routes");
   }
 
-  const snapshotRoutesMatch = normalizedRoutesDir.match(
-    /^(.*)\/\.rbssr\/dev\/server-snapshots\/v\d+\/routes$/,
-  );
-  if (snapshotRoutesMatch) {
-    return path.resolve(snapshotRoutesMatch[1]!, ".rbssr", "generated", "markdown-routes");
-  }
-
   return path.resolve(routesDir, "..", ".rbssr", "generated", "markdown-routes");
 }
 
 function toRouteGroupKey(routesDir: string): string {
-  const normalized = normalizeSlashes(path.resolve(routesDir));
-  const canonical = normalized.replace(
-    /\/\.rbssr\/dev\/server-snapshots\/v\d+\/routes$/,
-    "/.rbssr/dev/server-snapshots/routes",
-  );
-
-  return stableHash(`${MARKDOWN_WRAPPER_VERSION}\0${canonical}`);
+  return stableHash(`${MARKDOWN_WRAPPER_VERSION}\0${normalizeSlashes(path.resolve(routesDir))}`);
 }
 
 function parseFrontmatter(raw: string): {

package/framework/runtime/matcher.ts

@@ -60,10 +60,10 @@ function matchSegments(segments: RouteSegment[], pathname: string): Params | nul
   return params;
 }
 
-export function matchPageRoute(
-  routes: PageRouteDefinition[],
+export function matchRouteBySegments<T extends { segments: RouteSegment[] }>(
+  routes: T[],
   pathname: string,
-): RouteMatch<PageRouteDefinition> | null {
+): { route: T; params: Params } | null {
   for (const route of routes) {
     const params = matchSegments(route.segments, pathname);
     if (params) {
@@ -74,16 +74,16 @@ export function matchPageRoute(
   return null;
 }
 
+export function matchPageRoute(
+  routes: PageRouteDefinition[],
+  pathname: string,
+): RouteMatch<PageRouteDefinition> | null {
+  return matchRouteBySegments(routes, pathname);
+}
+
 export function matchApiRoute(
   routes: ApiRouteDefinition[],
   pathname: string,
 ): RouteMatch<ApiRouteDefinition> | null {
-  for (const route of routes) {
-    const params = matchSegments(route.segments, pathname);
-    if (params) {
-      return { route, params };
-    }
-  }
-
-  return null;
+  return matchRouteBySegments(routes, pathname);
 }

package/framework/runtime/module-loader.ts

@@ -28,21 +28,27 @@ const SERVER_BUILD_EXTERNAL = [
 export interface RouteModuleLoadOptions {
   cacheBustKey?: string;
   serverBytecode?: boolean;
+  devSourceImports?: boolean;
+  nodeEnv?: "development" | "production";
 }
 
 export function createServerModuleCacheKey(options: {
   absoluteFilePath: string;
   cacheBustKey?: string;
   serverBytecode: boolean;
+  nodeEnv?: "development" | "production";
 }): string {
-  return `${options.absoluteFilePath}|${options.cacheBustKey ?? 'prod'}|bytecode:${options.serverBytecode ? '1' : '0'}|bun:${Bun.version}`;
+  const nodeEnv = options.nodeEnv ?? (process.env.NODE_ENV === "production" ? "production" : "development");
+  return `${options.absoluteFilePath}|${options.cacheBustKey ?? 'prod'}|bytecode:${options.serverBytecode ? '1' : '0'}|env:${nodeEnv}|bun:${Bun.version}`;
 }
 
 export function createServerBuildConfig(options: {
   absoluteFilePath: string;
   outDir: string;
   serverBytecode: boolean;
+  nodeEnv?: "development" | "production";
 }): Bun.BuildConfig {
+  const nodeEnv = options.nodeEnv ?? (process.env.NODE_ENV === "production" ? "production" : "development");
   return {
     entrypoints: [options.absoluteFilePath],
     outdir: options.outDir,
@@ -55,6 +61,9 @@ export function createServerBuildConfig(options: {
     minify: false,
     naming: 'entry-[hash].[ext]',
     external: SERVER_BUILD_EXTERNAL,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    },
   };
 }
 
@@ -67,15 +76,21 @@ export async function importModule<T>(
   return (await import(url)) as T;
 }
 
+function normalizeLoadOptions(
+  options: string | RouteModuleLoadOptions | undefined,
+): RouteModuleLoadOptions {
+  if (typeof options === "string") {
+    return {
+      cacheBustKey: options,
+    };
+  }
+
+  return options ?? {};
+}
+
 function toRouteModule(filePath: string, moduleValue: unknown): RouteModule {
   const rawValue = moduleValue as Record<string, unknown>;
-  const value =
-    rawValue &&
-    typeof rawValue.default === 'object' &&
-    rawValue.default !== null &&
-    'default' in (rawValue.default as Record<string, unknown>)
-      ? (rawValue.default as Partial<RouteModule>)
-      : (rawValue as Partial<RouteModule>);
+  const value = unwrapModuleNamespace(rawValue) as Partial<RouteModule>;
   const component = value.default;
 
   if (typeof component !== 'function') {
@@ -93,6 +108,19 @@ function toRouteModule(filePath: string, moduleValue: unknown): RouteModule {
   } as RouteModule;
 }
 
+function unwrapModuleNamespace(moduleValue: Record<string, unknown>): Record<string, unknown> {
+  if (
+    moduleValue
+    && typeof moduleValue.default === "object"
+    && moduleValue.default !== null
+    && "default" in (moduleValue.default as Record<string, unknown>)
+  ) {
+    return moduleValue.default as Record<string, unknown>;
+  }
+
+  return moduleValue;
+}
+
 function isCompilableRouteModule(filePath: string): boolean {
   return /\.(tsx|jsx|ts|js)$/.test(filePath);
 }
@@ -108,10 +136,12 @@ async function buildServerModule(
 
   const cacheBustKey = options.cacheBustKey;
   const serverBytecode = options.serverBytecode ?? true;
+  const nodeEnv = options.nodeEnv ?? (process.env.NODE_ENV === "production" ? "production" : "development");
   const cacheKey = createServerModuleCacheKey({
     absoluteFilePath,
     cacheBustKey,
     serverBytecode,
+    nodeEnv,
   });
   const existing = serverBundlePathCache.get(cacheKey);
   if (existing) {
@@ -133,6 +163,7 @@ async function buildServerModule(
         absoluteFilePath,
         outDir,
         serverBytecode,
+        nodeEnv,
       }),
     );
 
@@ -149,6 +180,7 @@ async function buildServerModule(
           absoluteFilePath,
           outDir,
           serverBytecode: false,
+          nodeEnv,
         }),
       );
 
@@ -210,10 +242,13 @@ export async function loadRouteModule(
   filePath: string,
   options: RouteModuleLoadOptions = {},
 ): Promise<RouteModule> {
-  const bundledModulePath = await buildServerModule(filePath, options);
+  const normalizedOptions = normalizeLoadOptions(options);
+  const modulePath = normalizedOptions.devSourceImports
+    ? path.resolve(filePath)
+    : await buildServerModule(filePath, normalizedOptions);
   const moduleValue = await importModule<unknown>(
-    bundledModulePath,
-    options.cacheBustKey,
+    modulePath,
+    normalizedOptions.cacheBustKey,
   );
   return toRouteModule(filePath, moduleValue);
 }
@@ -224,10 +259,12 @@ export async function loadRouteModules(options: {
   routeFilePath: string;
   cacheBustKey?: string;
   serverBytecode?: boolean;
+  devSourceImports?: boolean;
 }): Promise<RouteModuleBundle> {
   const moduleOptions: RouteModuleLoadOptions = {
     cacheBustKey: options.cacheBustKey,
     serverBytecode: options.serverBytecode,
+    devSourceImports: options.devSourceImports,
   };
   const [root, layouts, route] = await Promise.all([
     loadRouteModule(options.rootFilePath, moduleOptions),
@@ -266,16 +303,20 @@ function normalizeMiddlewareExport(value: unknown): Middleware[] {
 
 export async function loadGlobalMiddleware(
   middlewareFilePath: string,
-  cacheBustKey?: string,
+  options: string | RouteModuleLoadOptions = {},
 ): Promise<Middleware[]> {
   if (!(await existsPath(middlewareFilePath))) {
     return [];
   }
 
-  const raw = await importModule<Record<string, unknown>>(
-    middlewareFilePath,
-    cacheBustKey,
-  );
+  const normalizedOptions = normalizeLoadOptions(options);
+  const modulePath = normalizedOptions.devSourceImports
+    ? path.resolve(middlewareFilePath)
+    : await buildServerModule(middlewareFilePath, normalizedOptions);
+  const raw = unwrapModuleNamespace(await importModule<Record<string, unknown>>(
+    modulePath,
+    normalizedOptions.cacheBustKey,
+  ));
 
   return [
     ...normalizeMiddlewareExport(raw.default),
@@ -285,14 +326,18 @@ export async function loadGlobalMiddleware(
 
 export async function loadNestedMiddleware(
   middlewareFilePaths: string[],
-  cacheBustKey?: string,
+  options: string | RouteModuleLoadOptions = {},
 ): Promise<Middleware[]> {
+  const normalizedOptions = normalizeLoadOptions(options);
   const rawModules = await Promise.all(
-    middlewareFilePaths.map((middlewareFilePath) => {
-      return importModule<Record<string, unknown>>(
-        middlewareFilePath,
-        cacheBustKey,
-      );
+    middlewareFilePaths.map(async (middlewareFilePath) => {
+      const modulePath = normalizedOptions.devSourceImports
+        ? path.resolve(middlewareFilePath)
+        : await buildServerModule(middlewareFilePath, normalizedOptions);
+      return unwrapModuleNamespace(await importModule<Record<string, unknown>>(
+        modulePath,
+        normalizedOptions.cacheBustKey,
+      ));
     }),
   );
 
@@ -310,8 +355,13 @@ export function extractRouteMiddleware(module: RouteModule): Middleware[] {
 
 export async function loadApiRouteModule(
   filePath: string,
-  cacheBustKey?: string,
+  options: string | RouteModuleLoadOptions = {},
 ): Promise<ApiRouteModule> {
-  const raw = await importModule<ApiRouteModule>(filePath, cacheBustKey);
-  return raw;
+  const normalizedOptions = normalizeLoadOptions(options);
+  const modulePath = normalizedOptions.devSourceImports
+    ? path.resolve(filePath)
+    : await buildServerModule(filePath, normalizedOptions);
+  return unwrapModuleNamespace(
+    await importModule<Record<string, unknown>>(modulePath, normalizedOptions.cacheBustKey),
+  ) as ApiRouteModule;
 }