react-bun-ssr 0.1.1 → 0.3.0

package/framework/runtime/build-tools.ts

@@ -5,6 +5,7 @@ import {
   ensureDir,
   existsPath,
   glob,
+  removePath,
   statPath,
   writeTextIfChanged,
 } from './io';
@@ -22,15 +23,22 @@ const BUILD_OPTIMIZE_IMPORTS = [
   'react-bun-ssr/route',
   'react',
   'react-dom',
-  '@datadog/browser-rum-react',
 ];
 
-interface ClientEntryFile {
+export interface ClientEntryFile {
   routeId: string;
   entryFilePath: string;
   route: PageRouteDefinition;
 }
 
+export interface ClientEntrySyncResult {
+  entries: ClientEntryFile[];
+  addedEntryPaths: string[];
+  changedEntryPaths: string[];
+  removedEntryPaths: string[];
+  entrySetChanged: boolean;
+}
+
 async function walkFiles(rootDir: string): Promise<string[]> {
   if (!(await existsPath(rootDir))) {
     return [];
@@ -39,6 +47,21 @@ async function walkFiles(rootDir: string): Promise<string[]> {
   return glob('**/*', { cwd: rootDir, absolute: true });
 }
 
+function buildClientModuleProjectionSource(defaultRef: string, moduleRef: string): string {
+  return `projectClientModule(${defaultRef}, ${moduleRef})`;
+}
+
+function toClientEntryFile(options: {
+  route: PageRouteDefinition;
+  entryFilePath: string;
+}): ClientEntryFile {
+  return {
+    routeId: options.route.id,
+    entryFilePath: options.entryFilePath,
+    route: options.route,
+  };
+}
+
 function buildClientEntrySource(options: {
   generatedDir: string;
   route: PageRouteDefinition;
@@ -54,7 +77,7 @@ function buildClientEntrySource(options: {
   const routeImport = toImportPath(generatedDir, route.filePath);
 
   imports.push(
-    `import { hydrateInitialRoute, registerRouteModules } from "${runtimeImport}";`,
+    `import { hydrateInitialRoute, projectClientModule, registerRouteModules } from "${runtimeImport}";`,
   );
 
   imports.push(`import RootDefault from "${rootImport}";`);
@@ -72,16 +95,16 @@ function buildClientEntrySource(options: {
       `import * as Layout${index}Module from "${layoutImportPath}";`,
     );
     layoutModuleRefs.push(
-      `{ ...Layout${index}Module, default: Layout${index}Default }`,
+      buildClientModuleProjectionSource(`Layout${index}Default`, `Layout${index}Module`),
     );
   }
 
   return `${imports.join('\n')}
 
 const modules = {
-  root: { ...RootModule, default: RootDefault },
+  root: ${buildClientModuleProjectionSource('RootDefault', 'RootModule')},
   layouts: [${layoutModuleRefs.join(', ')}],
-  route: { ...RouteModule, default: RouteDefault },
+  route: ${buildClientModuleProjectionSource('RouteDefault', 'RouteModule')},
 };
 
 registerRouteModules(${JSON.stringify(route.id)}, modules);
@@ -112,13 +135,84 @@ export async function generateClientEntries(options: {
 
       await writeTextIfChanged(entryFilePath, source);
 
-      return {
-        routeId: route.id,
+      return toClientEntryFile({
+        route,
         entryFilePath,
+      });
+    }),
+  );
+}
+
+export async function syncClientEntries(options: {
+  config: ResolvedConfig;
+  manifest: RouteManifest;
+  generatedDir: string;
+}): Promise<ClientEntrySyncResult> {
+  const { config, manifest, generatedDir } = options;
+  await ensureDir(generatedDir);
+
+  const runtimeClientFile = path.resolve(import.meta.dir, 'client-runtime.tsx');
+  const desiredEntries = new Map<string, { route: PageRouteDefinition; entryFilePath: string }>();
+  for (const route of manifest.pages) {
+    const entryFilePath = path.join(generatedDir, `route__${route.id}.tsx`);
+    desiredEntries.set(entryFilePath, {
+      route,
+      entryFilePath,
+    });
+  }
+
+  const existingEntryPaths = new Set(
+    (await glob('route__*.tsx', {
+      cwd: generatedDir,
+      absolute: true,
+    }))
+      .map((filePath) => path.resolve(filePath)),
+  );
+
+  const addedEntryPaths: string[] = [];
+  const changedEntryPaths: string[] = [];
+  const removedEntryPaths: string[] = [];
+
+  await Promise.all(
+    [...desiredEntries.values()].map(async ({ route, entryFilePath }) => {
+      const source = buildClientEntrySource({
+        generatedDir,
         route,
-      };
+        rootModulePath: config.rootModule,
+        runtimeClientFile,
+      });
+      const existed = existingEntryPaths.has(entryFilePath);
+      const changed = await writeTextIfChanged(entryFilePath, source);
+      if (!existed) {
+        addedEntryPaths.push(entryFilePath);
+      } else if (changed) {
+        changedEntryPaths.push(entryFilePath);
+      }
+      existingEntryPaths.delete(entryFilePath);
+    }),
+  );
+
+  await Promise.all(
+    [...existingEntryPaths].map(async (entryFilePath) => {
+      removedEntryPaths.push(entryFilePath);
+      await removePath(entryFilePath);
     }),
   );
+
+  const entries = manifest.pages.map((route) => {
+    return toClientEntryFile({
+      route,
+      entryFilePath: path.join(generatedDir, `route__${route.id}.tsx`),
+    });
+  });
+
+  return {
+    entries,
+    addedEntryPaths: addedEntryPaths.sort(),
+    changedEntryPaths: changedEntryPaths.sort(),
+    removedEntryPaths: removedEntryPaths.sort(),
+    entrySetChanged: addedEntryPaths.length > 0 || removedEntryPaths.length > 0,
+  };
 }
 
 async function mapBuildOutputsByPrefix(options: {
@@ -155,7 +249,7 @@ async function mapBuildOutputsByPrefix(options: {
   return routeAssets;
 }
 
-function normalizeMetafilePath(filePath: string): string {
+export function normalizeMetafilePath(filePath: string): string {
   return normalizeSlashes(filePath).replace(/^\.\//, "");
 }
 
@@ -163,7 +257,7 @@ function toPublicBuildPath(publicPrefix: string, filePath: string): string {
   return `${publicPrefix}${normalizeMetafilePath(filePath)}`;
 }
 
-function mapBuildOutputsFromMetafile(options: {
+export function mapBuildOutputsFromMetafile(options: {
   metafile: Bun.BuildMetafile;
   entries: ClientEntryFile[];
   publicPrefix: string;
@@ -204,6 +298,21 @@ function mapBuildOutputsFromMetafile(options: {
   return routeAssets;
 }
 
+export function listBuildOutputFiles(metafile: Bun.BuildMetafile): string[] {
+  return Object.keys(metafile.outputs)
+    .map(normalizeMetafilePath)
+    .sort();
+}
+
+export function createClientEntrySetSignature(entries: ClientEntryFile[]): string {
+  return stableHash(
+    entries
+      .map((entry) => normalizeSlashes(path.resolve(entry.entryFilePath)))
+      .sort()
+      .join('|'),
+  );
+}
+
 export async function bundleClientEntries(options: {
   entries: ClientEntryFile[];
   outDir: string;
@@ -228,6 +337,9 @@ export async function bundleClientEntries(options: {
     sourcemap: dev ? 'inline' : 'external',
     minify: !dev,
     naming: dev ? '[name].[ext]' : '[name]-[hash].[ext]',
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(dev ? "development" : "production"),
+    },
   });
 
   if (!result.success) {
@@ -299,8 +411,17 @@ export function createBuildManifest(
   };
 }
 
-export async function discoverFileSignature(rootDir: string): Promise<string> {
-  const files = (await walkFiles(rootDir))
+export async function discoverFileSignature(rootPath: string): Promise<string> {
+  const rootStat = await statPath(rootPath);
+  if (!rootStat) {
+    return stableHash("");
+  }
+
+  const files = (
+    rootStat.isFile()
+      ? [rootPath]
+      : await walkFiles(rootPath)
+  )
     .filter((file) => !normalizeSlashes(file).includes('/node_modules/'))
     .sort();
 

package/framework/runtime/bun-route-adapter.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { ensureCleanDir, ensureDir, writeTextIfChanged } from "./io";
+import { ensureDir, glob, removePath, writeTextIfChanged } from "./io";
+import { matchRouteBySegments } from "./matcher";
 import { scanRoutes } from "./route-scanner";
 import type {
   ApiRouteDefinition,
@@ -116,17 +117,30 @@ async function writeProjectionRoutes<T extends PageRouteDefinition | ApiRouteDef
     }),
   );
 
+  const expectedPaths = new Set(writes.map(({ projectedFilePath }) => path.resolve(projectedFilePath)));
+  const existingPaths = new Set(await glob(`**/*${extension}`, {
+    cwd: outDir,
+    absolute: true,
+  }));
+
+  await Promise.all(
+    [...existingPaths]
+      .filter((projectedFilePath) => !expectedPaths.has(path.resolve(projectedFilePath)))
+      .map((projectedFilePath) => removePath(projectedFilePath)),
+  );
+
   return byProjectedFilePath;
 }
 
 function toRouteMatch<T extends PageRouteDefinition | ApiRouteDefinition>(
+  orderedRoutes: T[],
   routeByProjectedPath: Map<string, T>,
   pathname: string,
   router: Bun.FileSystemRouter,
 ): RouteMatch<T> | null {
   const matched = router.match(pathname);
   if (!matched) {
-    return null;
+    return matchRouteBySegments(orderedRoutes, pathname);
   }
 
   const matchedSource = normalizeRouteKey(
@@ -136,7 +150,7 @@ function toRouteMatch<T extends PageRouteDefinition | ApiRouteDefinition>(
   );
   const route = routeByProjectedPath.get(matchedSource);
   if (!route) {
-    return null;
+    return matchRouteBySegments(orderedRoutes, pathname);
   }
 
   return {
@@ -153,8 +167,7 @@ export async function createBunRouteAdapter(options: {
   const manifest = await scanRoutes(options.routesDir, {
     generatedMarkdownRootDir: options.generatedMarkdownRootDir,
   });
-
-  await ensureCleanDir(options.projectionRootDir);
+  await ensureDir(options.projectionRootDir);
 
   const pagesProjectionDir = path.join(options.projectionRootDir, "pages");
   const apiProjectionDir = path.join(options.projectionRootDir, "api");
@@ -191,10 +204,10 @@ export async function createBunRouteAdapter(options: {
   return {
     manifest,
     matchPage(pathname) {
-      return toRouteMatch(pageRouteByProjectedPath, pathname, pageRouter);
+      return toRouteMatch(manifest.pages, pageRouteByProjectedPath, pathname, pageRouter);
     },
     matchApi(pathname) {
-      return toRouteMatch(apiRouteByProjectedPath, pathname, apiRouter);
+      return toRouteMatch(manifest.api, apiRouteByProjectedPath, pathname, apiRouter);
     },
   };
 }