@reckona/mreact-router 0.0.175 → 0.0.176

package/src/render.ts

@@ -144,6 +144,12 @@ import {
   prebuiltServerModuleOutputOptionsMatch,
   type BuiltServerModuleOutputLike,
 } from "./route-module-loader.js";
+import {
+  loadRouteDataFromModule,
+  type RouteDataContext,
+  type RouteLoaderModule,
+} from "./route-loader-runtime.js";
+import { pageRouteMethodResponse } from "./route-dispatch.js";
 
 const nativeEscapeTransform = {
   batchImportName: "escapeHtmlBatch",
@@ -166,6 +172,13 @@ interface RenderTiming {
   phases: Record<string, number>;
 }
 
+/**
+ * Loads prebuilt server render artifacts immediately before a route render needs them.
+ */
+export interface AppRouterServerRenderArtifactLoader {
+  load(routeFile: string): Promise<void>;
+}
+
 /**
  * Configures server rendering for a source app-router request.
  */
@@ -205,6 +218,10 @@ export interface RenderAppRequestOptions {
   vitePlugins?: readonly PluginOption[] | undefined;
 }
 
+export interface RenderAppRequestRuntimeOptions extends RenderAppRequestOptions {
+  serverRenderArtifactLoader?: AppRouterServerRenderArtifactLoader | undefined;
+}
+
 export interface AppRouterRenderPreload {
   promise: Promise<void>;
   wait: "before-render";
@@ -723,15 +740,11 @@ async function waitForRenderPreload(
 }
 
 async function loadServerRenderArtifacts(
-  options: RenderAppRequestOptions,
+  options: RenderAppRequestRuntimeOptions,
   routeFile: string,
   timing: RenderTiming | undefined,
 ): Promise<void> {
-  const loader = (
-    options as RenderAppRequestOptions & {
-      __mreactLoadServerRenderArtifacts?: ((routeFile: string) => Promise<void>) | undefined;
-    }
-  ).__mreactLoadServerRenderArtifacts;
+  const loader = options.serverRenderArtifactLoader;
 
   if (loader === undefined) {
     return;
@@ -739,14 +752,14 @@ async function loadServerRenderArtifacts(
 
   const phaseStartedAt = renderTimingPhaseStartedAt(timing);
   try {
-    await loader(routeFile);
+    await loader.load(routeFile);
   } finally {
     finishRenderTimingPhase(timing, phaseStartedAt, "renderArtifactLoadMs");
   }
 }
 
 function emitRenderTiming(
-  options: RenderAppRequestOptions,
+  options: RenderAppRequestRuntimeOptions,
   timing: RenderTiming | undefined,
   status: number,
 ): void {
@@ -798,7 +811,7 @@ export async function resolveAppRouterMiddleware(options: {
   return { response: middlewareResponse, type: "response" };
 }
 
-async function renderAppRequestInternal(options: RenderAppRequestOptions): Promise<Response> {
+async function renderAppRequestInternal(options: RenderAppRequestRuntimeOptions): Promise<Response> {
   warnProductionRenderWithoutPrebuiltModules(options);
   const timing = createRenderTiming(options.logger);
   const clientRouteInferenceCache =
@@ -967,18 +980,9 @@ async function renderAppRequestInternal(options: RenderAppRequestOptions): Promi
     // methods (PUT, PATCH, DELETE, PROPFIND, ...) get 405 with an
     // Allow header so the response shape complies with RFC 9110 §9
     // and so caching intermediaries do not cross-cache method results.
-    const method = options.request.method;
-    if (method === "OPTIONS") {
-      return new Response(null, {
-        status: 204,
-        headers: { allow: "GET, HEAD, OPTIONS" },
-      });
-    }
-    if (method !== "GET" && method !== "HEAD") {
-      return new Response("Method Not Allowed", {
-        status: 405,
-        headers: { allow: "GET, HEAD, OPTIONS" },
-      });
+    const methodResponse = pageRouteMethodResponse(options.request.method);
+    if (methodResponse !== undefined) {
+      return methodResponse;
     }
 
     routeCacheContext = beginRouteCacheContext(options.routeCache);
@@ -4389,17 +4393,6 @@ async function loadRouteMiddlewareControlFile(options: {
   return control;
 }
 
-interface RouteDataContext {
-  env?: unknown;
-  params: RouteParams;
-  queryClient: QueryClient;
-  request: Request;
-}
-
-interface RouteLoaderModule {
-  loader?: (context: RouteDataContext) => unknown;
-}
-
 interface RouteMetadataContext {
   data: unknown;
   params: RouteParams;
@@ -4427,34 +4420,19 @@ async function loadRouteData(options: {
   timing?: RenderTiming | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<unknown> {
-  if (!hasLoaderExport(options.code)) {
-    return undefined;
-  }
-
-  let module: RouteLoaderModule;
-  const moduleLoadStartedAt = renderTimingPhaseStartedAt(options.timing);
-  try {
-    module = await loadRouteLoaderModule(options);
-  } finally {
-    finishRenderTimingPhase(options.timing, moduleLoadStartedAt, "loaderModuleLoadMs");
-  }
-
-  if (module.loader === undefined) {
-    return undefined;
-  }
-
-  const executionStartedAt = renderTimingPhaseStartedAt(options.timing);
-  try {
-    return await module.loader(options.context);
-  } catch (error) {
-    if (error instanceof Response) {
-      return error;
-    }
-
-    throw error;
-  } finally {
-    finishRenderTimingPhase(options.timing, executionStartedAt, "loaderExecutionMs");
-  }
+  return await loadRouteDataFromModule({
+    context: options.context,
+    hasLoader: hasLoaderExport(options.code),
+    loadModule: () => loadRouteLoaderModule(options),
+    timing: {
+      finish(startedAt, phase) {
+        finishRenderTimingPhase(options.timing, startedAt, phase);
+      },
+      start() {
+        return renderTimingPhaseStartedAt(options.timing);
+      },
+    },
+  });
 }
 
 async function loadRouteDataWithInstrumentation(options: {

package/src/route-dispatch.ts

@@ -0,0 +1,17 @@
+export function pageRouteMethodResponse(method: string): Response | undefined {
+  if (method === "GET" || method === "HEAD") {
+    return undefined;
+  }
+
+  if (method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
+      headers: { allow: "GET, HEAD, OPTIONS" },
+    });
+  }
+
+  return new Response("Method Not Allowed", {
+    status: 405,
+    headers: { allow: "GET, HEAD, OPTIONS" },
+  });
+}

package/src/route-loader-runtime.ts

@@ -0,0 +1,54 @@
+import type { QueryClient } from "@reckona/mreact-query";
+import type { RouteParams } from "./types.js";
+
+export interface RouteDataContext {
+  env?: unknown;
+  params: RouteParams;
+  queryClient: QueryClient;
+  request: Request;
+}
+
+export interface RouteLoaderModule {
+  loader?: (context: RouteDataContext) => unknown;
+}
+
+export interface RouteLoaderRuntimeTiming {
+  finish(startedAt: number | undefined, phase: "loaderExecutionMs" | "loaderModuleLoadMs"): void;
+  start(): number | undefined;
+}
+
+export async function loadRouteDataFromModule(options: {
+  context: RouteDataContext;
+  hasLoader: boolean;
+  loadModule(): Promise<RouteLoaderModule>;
+  timing?: RouteLoaderRuntimeTiming | undefined;
+}): Promise<unknown> {
+  if (!options.hasLoader) {
+    return undefined;
+  }
+
+  let module: RouteLoaderModule;
+  const moduleLoadStartedAt = options.timing?.start();
+  try {
+    module = await options.loadModule();
+  } finally {
+    options.timing?.finish(moduleLoadStartedAt, "loaderModuleLoadMs");
+  }
+
+  if (module.loader === undefined) {
+    return undefined;
+  }
+
+  const executionStartedAt = options.timing?.start();
+  try {
+    return await module.loader(options.context);
+  } catch (error) {
+    if (error instanceof Response) {
+      return error;
+    }
+
+    throw error;
+  } finally {
+    options.timing?.finish(executionStartedAt, "loaderExecutionMs");
+  }
+}

package/src/routes.ts

@@ -80,6 +80,11 @@ export interface RouteMatcher {
   match(pathname: string): MatchedRoute | undefined;
 }
 
+interface MatchRouteCacheEntry {
+  fingerprint: string;
+  matcher: RouteMatcher;
+}
+
 export type CompiledRouteMatcherSegment =
   | { kind: "static"; value: string }
   | { kind: "dynamic"; name: string }
@@ -99,6 +104,11 @@ export interface CompiledRouteMatcherArtifact {
   version: 1;
 }
 
+let matchRouteMatcherCache = new WeakMap<readonly AppRoute[], MatchRouteCacheEntry>();
+let matchRouteMatcherBuildCountForTest = 0;
+let matchRouteFingerprintIds = new WeakMap<AppRoute, number>();
+let nextMatchRouteFingerprintId = 1;
+
 /**
  * Scans an app directory and returns sorted app-router route definitions.
  */
@@ -137,7 +147,28 @@ export function matchRoute(
   routes: readonly AppRoute[],
   pathname: string,
 ): MatchedRoute | undefined {
-  return createRouteMatcher(routes).match(pathname);
+  const fingerprint = routeMatcherFingerprint(routes);
+  const cached = matchRouteMatcherCache.get(routes);
+
+  if (cached !== undefined && cached.fingerprint === fingerprint) {
+    return cached.matcher.match(pathname);
+  }
+
+  const matcher = createRouteMatcher(routes);
+  matchRouteMatcherBuildCountForTest += 1;
+  matchRouteMatcherCache.set(routes, { fingerprint, matcher });
+  return matcher.match(pathname);
+}
+
+export function __resetMatchRouteCacheForTest(): void {
+  matchRouteMatcherCache = new WeakMap();
+  matchRouteMatcherBuildCountForTest = 0;
+  matchRouteFingerprintIds = new WeakMap();
+  nextMatchRouteFingerprintId = 1;
+}
+
+export function __getMatchRouteMatcherBuildCountForTest(): number {
+  return matchRouteMatcherBuildCountForTest;
 }
 
 export function compileRouteMatcherArtifact(
@@ -204,6 +235,44 @@ function compileRouteMatcherEntry(
       };
 }
 
+function routeMatcherFingerprint(routes: readonly AppRoute[]): string {
+  const parts: string[] = [String(routes.length)];
+
+  for (const route of routes) {
+    parts.push(
+      String(routeMatcherRouteFingerprintId(route)),
+      route.kind,
+      route.path,
+      String(route.segments.length),
+    );
+
+    for (const segment of route.segments) {
+      parts.push(segment.kind);
+
+      if (segment.kind === "static") {
+        parts.push(segment.value);
+      } else {
+        parts.push(segment.name);
+      }
+    }
+  }
+
+  return parts.map((part) => `${part.length}:${part}`).join("|");
+}
+
+function routeMatcherRouteFingerprintId(route: AppRoute): number {
+  const cached = matchRouteFingerprintIds.get(route);
+
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const id = nextMatchRouteFingerprintId;
+  nextMatchRouteFingerprintId += 1;
+  matchRouteFingerprintIds.set(route, id);
+  return id;
+}
+
 function matchCompiledRoutes(
   routes: readonly AppRoute[],
   artifact: CompiledRouteMatcherArtifact,