@reckona/mreact-router 0.0.11 → 0.0.13

package/dist/render.js

@@ -24,13 +24,60 @@ const nativeEscapeTransform = {
 };
 const authRuntimeStateKey = "__mreactAuthRuntimeState";
 const authSessionScriptId = "__mreact_auth_session";
+export async function preloadBuiltRequestModules(options) {
+    const tasks = [];
+    const middlewareFiles = [
+        join(options.appDir, "middleware.ts"),
+        join(options.appDir, "middleware.mreact.ts"),
+    ];
+    for (const file of middlewareFiles) {
+        if (options.serverSourceFiles.has(file)) {
+            tasks.push(loadMiddlewareModule({
+                appDir: options.appDir,
+                file,
+                importPolicy: options.importPolicy,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
+                serverSourceFiles: options.serverSourceFiles,
+            }));
+        }
+    }
+    for (const route of options.routes) {
+        const code = await readServerSourceFile(route.file, options.serverModuleCacheVersion, options.serverSourceFiles);
+        if (route.kind === "server") {
+            tasks.push(loadServerRouteModule({
+                file: route.file,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
+                serverSourceFiles: options.serverSourceFiles,
+            }));
+            continue;
+        }
+        if (hasLoaderExport(code)) {
+            tasks.push(loadRouteLoaderModule({
+                appDir: options.appDir,
+                code,
+                filename: route.file,
+                importPolicy: options.importPolicy,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
+            }));
+        }
+    }
+    await Promise.all(tasks);
+}
 const serverTransformCache = new Map();
 const serverSourceFileCache = new Map();
 const routeSourceAnalysisCache = new Map();
+const routeOutOfOrderBoundaryAnalysisCache = new Map();
+const routeLoaderModuleCache = new Map();
+const middlewareModuleCache = new Map();
+const serverRouteModuleCache = new Map();
 const composedRouteMetadataCache = new Map();
 const maxServerTransformCacheEntries = 512;
 const maxServerSourceFileCacheEntries = 512;
 const maxRouteSourceAnalysisCacheEntries = 512;
+const maxRouteOutOfOrderBoundaryAnalysisCacheEntries = 512;
+const maxRouteLoaderModuleCacheEntries = 512;
+const maxMiddlewareModuleCacheEntries = 64;
+const maxServerRouteModuleCacheEntries = 512;
 const maxComposedRouteMetadataCacheEntries = 512;
 // Issue 086: per-shell prefix/suffix cache. Pure layouts (whose
 // exported component takes zero arguments and therefore cannot
@@ -62,6 +109,8 @@ async function renderAppRequestInternal(options) {
             appDir: options.appDir,
             importPolicy: options.importPolicy,
             request: options.request,
+            serverModuleCacheVersion: options.serverModuleCacheVersion,
+            serverSourceFiles: options.serverSourceFiles,
         });
     if (middlewareResponse !== undefined) {
         const location = rewriteLocation(middlewareResponse);
@@ -113,7 +162,13 @@ async function renderAppRequestInternal(options) {
     let routeCacheContext;
     try {
         if (matched.route.kind === "server") {
-            return await dispatchServerRoute(matched.route.file, options.request, matched.params);
+            return await dispatchServerRoute({
+                file: matched.route.file,
+                params: matched.params,
+                request: options.request,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
+                serverSourceFiles: options.serverSourceFiles,
+            });
         }
         // Issue 080: page routes render HTML for GET / HEAD only. Other
         // methods (PUT, PATCH, DELETE, PROPFIND, ...) get 405 with an
@@ -142,6 +197,7 @@ async function renderAppRequestInternal(options) {
             serverModuleCacheVersion: options.serverModuleCacheVersion,
         });
         const cachePolicy = originalAnalysis.cachePolicy;
+        const navigationScript = options.navigationScripts?.get(matched.route.path);
         const cacheKey = routeCacheKey(options.appDir, matched.route.path, url);
         const mayUseRouteCache = cachePolicy === undefined
             ? originalAnalysis.usesRuntimeCacheControl
@@ -185,6 +241,7 @@ async function renderAppRequestInternal(options) {
                 appDir: options.appDir,
                 filename: matched.route.file,
                 importPolicy: options.importPolicy,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
             })
             : undefined;
         recoveryRoute = {
@@ -206,7 +263,13 @@ async function renderAppRequestInternal(options) {
                 "content-type": "text/html; charset=utf-8",
                 "x-mreact-stream": "1",
             };
-            if (loadingFile === undefined && !mayRenderOutOfOrderBoundary(routeCode)) {
+            const mayRenderOutOfOrder = await mayRenderOutOfOrderBoundaryDeep({
+                code: routeCode,
+                filename: matched.route.file,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
+                serverSourceFiles: options.serverSourceFiles,
+            });
+            if (loadingFile === undefined && !mayRenderOutOfOrder) {
                 const stringOutput = transformServerModule({
                     code: routeCode,
                     clientBoundaryImports: clientInference.clientBoundaryImports,
@@ -282,6 +345,7 @@ async function renderAppRequestInternal(options) {
                 return withOptionalActionCookie(htmlResponse(`<!DOCTYPE html>${clientNavigationHeadTags({
                     assetBaseUrl: options.assetBaseUrl,
                     currentScript: clientRoute ? clientScript : undefined,
+                    currentNavigationScript: clientRoute ? undefined : navigationScript,
                     routeScripts: options.clientScripts,
                 })}${html}`, { headers }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
             }
@@ -429,6 +493,7 @@ async function renderAppRequestInternal(options) {
         const response = withOptionalActionCookie(htmlResponse(`<!DOCTYPE html>${clientNavigationHeadTags({
             assetBaseUrl: options.assetBaseUrl,
             currentScript: clientRoute ? clientScript : undefined,
+            currentNavigationScript: clientRoute ? undefined : navigationScript,
             routeScripts: options.clientScripts,
         })}${html}`, {
             headers: responseHeadersForMetadata(metadata),
@@ -519,9 +584,15 @@ function modulePreloadTags(script, assetBaseUrl) {
 function clientNavigationHeadTags(options) {
     return [
         modulePreloadTags(options.currentScript, options.assetBaseUrl),
+        navigationRuntimeScriptTag(options.currentNavigationScript, options.assetBaseUrl),
         routePrefetchManifestScript(options.routeScripts, options.assetBaseUrl),
     ].join("");
 }
+function navigationRuntimeScriptTag(script, assetBaseUrl) {
+    return script === undefined
+        ? ""
+        : `<script type="module" src="${escapeHtmlAttribute(assetPath(script, assetBaseUrl ?? "/_mreact/client/"))}"></script>`;
+}
 function routePrefetchManifestScript(routeScripts, assetBaseUrl) {
     if (routeScripts === undefined || routeScripts.size === 0) {
         return "";
@@ -665,15 +736,15 @@ function normalizeErrorForProps(error) {
     }
     return { message: String(error) };
 }
-async function dispatchServerRoute(file, request, params) {
-    const module = await importAppRouterFileModule(file);
-    const handler = module[request.method] ?? module.ALL ?? module.default;
+async function dispatchServerRoute(options) {
+    const module = await loadServerRouteModule(options);
+    const handler = module[options.request.method] ?? module.ALL ?? module.default;
     if (typeof handler !== "function") {
         return new Response("Method Not Allowed", { status: 405 });
     }
     let response;
     try {
-        response = await handler(request, { params });
+        response = await handler(options.request, { params: options.params });
     }
     catch (error) {
         if (error instanceof Response) {
@@ -685,6 +756,29 @@ async function dispatchServerRoute(file, request, params) {
         ? response
         : new Response("Invalid route response", { status: 500 });
 }
+async function loadServerRouteModule(options) {
+    if (options.serverModuleCacheVersion === undefined) {
+        return await importAppRouterFileModule(options.file);
+    }
+    const code = await readServerSourceFile(options.file, options.serverModuleCacheVersion, options.serverSourceFiles);
+    const cacheKey = `server-route\0${options.file}\0${options.serverModuleCacheVersion}\0${memoizedHashText(code)}`;
+    const cached = serverRouteModuleCache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const loaded = importAppRouterSourceModule({
+        cacheKey,
+        code,
+        label: `server-route:${options.file}`,
+        resolveDir: dirname(options.file),
+        sourcefile: options.file,
+    }).catch((error) => {
+        serverRouteModuleCache.delete(cacheKey);
+        throw error;
+    });
+    setBoundedCacheEntry(serverRouteModuleCache, cacheKey, loaded, maxServerRouteModuleCacheEntries);
+    return loaded;
+}
 async function runMiddleware(options) {
     const candidates = [
         join(options.appDir, "middleware.ts"),
@@ -701,6 +795,8 @@ async function runMiddleware(options) {
             appDir: options.appDir,
             file,
             importPolicy: options.importPolicy,
+            serverModuleCacheVersion: options.serverModuleCacheVersion,
+            serverSourceFiles: options.serverSourceFiles,
         });
         if (!middlewareMatches(module.config, new URL(options.request.url).pathname)) {
             return undefined;
@@ -729,7 +825,34 @@ async function runMiddleware(options) {
     return undefined;
 }
 async function loadMiddlewareModule(options) {
-    const code = await readFile(options.file, "utf8");
+    const code = await readServerSourceFile(options.file, options.serverModuleCacheVersion, options.serverSourceFiles);
+    const cacheKey = options.serverModuleCacheVersion === undefined
+        ? undefined
+        : `middleware\0${options.appDir}\0${options.file}\0${options.serverModuleCacheVersion}\0${memoizedHashText(code)}\0${importPolicyCacheKey(options.importPolicy)}`;
+    if (cacheKey !== undefined) {
+        const cached = middlewareModuleCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+    }
+    const loaded = bundleMiddlewareModule({
+        appDir: options.appDir,
+        code,
+        file: options.file,
+        importPolicy: options.importPolicy,
+        serverModuleCacheVersion: options.serverModuleCacheVersion,
+    }).catch((error) => {
+        if (cacheKey !== undefined) {
+            middlewareModuleCache.delete(cacheKey);
+        }
+        throw error;
+    });
+    if (cacheKey !== undefined) {
+        setBoundedCacheEntry(middlewareModuleCache, cacheKey, loaded, maxMiddlewareModuleCacheEntries);
+    }
+    return loaded;
+}
+async function bundleMiddlewareModule(options) {
     const output = await bundle({
         bundle: true,
         format: "esm",
@@ -747,7 +870,7 @@ async function loadMiddlewareModule(options) {
         jsxFactory: "__mreact_jsx",
         jsxFragment: "__mreact_fragment",
         stdin: {
-            contents: code,
+            contents: options.code,
             loader: "ts",
             resolveDir: dirname(options.file),
             sourcefile: options.file,
@@ -758,6 +881,11 @@ async function loadMiddlewareModule(options) {
         throw new Error(`Failed to compile middleware for ${options.file}.`);
     }
     return importAppRouterSourceModule({
+        ...(options.serverModuleCacheVersion === undefined
+            ? {}
+            : {
+                cacheKey: `middleware:${options.file}:${options.serverModuleCacheVersion}:${memoizedHashText(compiled)}`,
+            }),
         code: compiled,
         label: `middleware:${options.file}`,
     });
@@ -987,6 +1115,92 @@ function hasOutOfOrderBoundary(code) {
 function mayRenderOutOfOrderBoundary(code) {
     return (code.includes("<Await") || code.includes("Await(") || code.includes("renderOutOfOrderBoundary"));
 }
+async function mayRenderOutOfOrderBoundaryDeep(options) {
+    const seen = new Set();
+    return await mayRenderOutOfOrderBoundaryDeepInner(options, seen);
+}
+async function mayRenderOutOfOrderBoundaryDeepInner(options, seen) {
+    if (mayRenderOutOfOrderBoundary(options.code)) {
+        return true;
+    }
+    if (seen.has(options.filename)) {
+        return false;
+    }
+    seen.add(options.filename);
+    const sourceHash = memoizedHashText(options.code);
+    const cacheKey = `${options.serverModuleCacheVersion ?? "dev"}\0${options.filename}\0${sourceHash}`;
+    const cached = routeOutOfOrderBoundaryAnalysisCache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const pending = mayRenderImportedOutOfOrderBoundary(options, seen).catch((error) => {
+        routeOutOfOrderBoundaryAnalysisCache.delete(cacheKey);
+        throw error;
+    });
+    setBoundedCacheEntry(routeOutOfOrderBoundaryAnalysisCache, cacheKey, pending, maxRouteOutOfOrderBoundaryAnalysisCacheEntries);
+    return pending;
+}
+async function mayRenderImportedOutOfOrderBoundary(options, seen) {
+    for (const specifier of localModuleSpecifiers(options.code)) {
+        const file = await resolveLocalServerSourceImport(options.filename, specifier);
+        if (file === undefined) {
+            continue;
+        }
+        const code = await readServerSourceFile(file, options.serverModuleCacheVersion, options.serverSourceFiles);
+        if (await mayRenderOutOfOrderBoundaryDeepInner({
+            code,
+            filename: file,
+            serverModuleCacheVersion: options.serverModuleCacheVersion,
+            serverSourceFiles: options.serverSourceFiles,
+        }, seen)) {
+            return true;
+        }
+    }
+    return false;
+}
+function localModuleSpecifiers(code) {
+    const specifiers = new Set();
+    const importPattern = /\b(?:import|export)\s+(?:type\s+)?(?:[^"']*?\s+from\s*)?["'](?<source>\.{1,2}\/[^"']+)["']/g;
+    for (const match of code.matchAll(importPattern)) {
+        const source = match.groups?.source;
+        if (source !== undefined) {
+            specifiers.add(source);
+        }
+    }
+    return Array.from(specifiers);
+}
+async function resolveLocalServerSourceImport(fromFile, specifier) {
+    const base = join(dirname(fromFile), specifier);
+    const candidates = localServerSourceImportCandidates(base);
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            // Try the next TypeScript route/source extension.
+        }
+    }
+    return undefined;
+}
+function localServerSourceImportCandidates(base) {
+    const candidates = [base];
+    if (base.endsWith(".js")) {
+        const withoutJs = base.slice(0, -".js".length);
+        candidates.push(`${withoutJs}.ts`, `${withoutJs}.tsx`, `${withoutJs}.mreact.tsx`);
+    }
+    else if (base.endsWith(".jsx")) {
+        const withoutJsx = base.slice(0, -".jsx".length);
+        candidates.push(`${withoutJsx}.tsx`, `${withoutJsx}.mreact.tsx`);
+    }
+    else if (base.endsWith(".mreact")) {
+        candidates.push(`${base}.tsx`);
+    }
+    else {
+        candidates.push(`${base}.ts`, `${base}.tsx`, `${base}.mreact.tsx`, join(base, "index.ts"), join(base, "index.tsx"), join(base, "index.mreact.tsx"));
+    }
+    return candidates;
+}
 async function runServerStreamModuleWithLoading(code, options) {
     const loadingProps = {
         data: undefined,
@@ -1338,6 +1552,31 @@ async function loadRouteData(options) {
     if (!hasLoaderExport(options.code)) {
         return undefined;
     }
+    const module = await loadRouteLoaderModule(options);
+    return module.loader === undefined ? undefined : await module.loader(options.context);
+}
+async function loadRouteLoaderModule(options) {
+    const cacheKey = options.serverModuleCacheVersion === undefined
+        ? undefined
+        : `${options.appDir}\0${options.filename}\0${options.serverModuleCacheVersion}\0${memoizedHashText(options.code)}\0${importPolicyCacheKey(options.importPolicy)}`;
+    if (cacheKey !== undefined) {
+        const cached = routeLoaderModuleCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+    }
+    const loaded = bundleRouteLoaderModule(options).catch((error) => {
+        if (cacheKey !== undefined) {
+            routeLoaderModuleCache.delete(cacheKey);
+        }
+        throw error;
+    });
+    if (cacheKey !== undefined) {
+        setBoundedCacheEntry(routeLoaderModuleCache, cacheKey, loaded, maxRouteLoaderModuleCacheEntries);
+    }
+    return loaded;
+}
+async function bundleRouteLoaderModule(options) {
     const output = await bundle({
         bundle: true,
         format: "esm",
@@ -1365,11 +1604,25 @@ async function loadRouteData(options) {
     if (code === undefined) {
         throw new Error(`Failed to compile loader for ${options.filename}.`);
     }
-    const module = await importAppRouterSourceModule({
+    return await importAppRouterSourceModule({
+        ...(options.serverModuleCacheVersion === undefined
+            ? {}
+            : {
+                cacheKey: `loader:${options.filename}:${options.serverModuleCacheVersion}:${memoizedHashText(code)}`,
+            }),
         code,
         label: `loader:${options.filename}`,
     });
-    return module.loader === undefined ? undefined : await module.loader(options.context);
+}
+function importPolicyCacheKey(policy) {
+    if (policy === undefined) {
+        return "";
+    }
+    return JSON.stringify({
+        allowedPackages: [...(policy.allowedPackages ?? [])].sort(),
+        allowedSourceDirs: [...(policy.allowedSourceDirs ?? [])].sort(),
+        projectRoot: policy.projectRoot ?? "",
+    });
 }
 async function loadRouteMetadata(options) {
     if (!hasMetadataExport(options.code)) {