npm - @reckona/mreact-router - Versions diffs - 0.0.11 → 0.0.12 - Mend

@reckona/mreact-router 0.0.11 → 0.0.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/README.md +26 -0
package/dist/adapters/aws-lambda.d.ts +1 -0
package/dist/adapters/aws-lambda.d.ts.map +1 -1
package/dist/adapters/aws-lambda.js +60 -0
package/dist/adapters/aws-lambda.js.map +1 -1
package/dist/adapters/cloudflare.js +1 -1
package/dist/adapters/cloudflare.js.map +1 -1
package/dist/app-router-globals.d.ts +6 -0
package/dist/app-router-globals.d.ts.map +1 -1
package/dist/app-router-globals.js.map +1 -1
package/dist/build.d.ts.map +1 -1
package/dist/build.js +33 -19
package/dist/build.js.map +1 -1
package/dist/cli-options.d.ts +13 -0
package/dist/cli-options.d.ts.map +1 -0
package/dist/cli-options.js +76 -0
package/dist/cli-options.js.map +1 -0
package/dist/cli.js +49 -27
package/dist/cli.js.map +1 -1
package/dist/client.d.ts +11 -0
package/dist/client.d.ts.map +1 -1
package/dist/client.js +36 -2
package/dist/client.js.map +1 -1
package/dist/dev-server.d.ts +2 -0
package/dist/dev-server.d.ts.map +1 -1
package/dist/dev-server.js +24 -0
package/dist/dev-server.js.map +1 -1
package/dist/render.d.ts +1 -0
package/dist/render.d.ts.map +1 -1
package/dist/render.js +224 -10
package/dist/render.js.map +1 -1
package/dist/serve.d.ts +1 -0
package/dist/serve.d.ts.map +1 -1
package/dist/serve.js +20 -8
package/dist/serve.js.map +1 -1
package/dist/vite.d.ts.map +1 -1
package/dist/vite.js +20 -1
package/dist/vite.js.map +1 -1
package/package.json +8 -8

package/dist/render.js CHANGED Viewed

@@ -27,10 +27,18 @@ const authSessionScriptId = "__mreact_auth_session";
 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 +70,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 +123,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 +158,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 +202,7 @@ async function renderAppRequestInternal(options) {
                 appDir: options.appDir,
                 filename: matched.route.file,
                 importPolicy: options.importPolicy,
+                serverModuleCacheVersion: options.serverModuleCacheVersion,
             })
             : undefined;
         recoveryRoute = {
@@ -206,7 +224,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 +306,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 +454,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 +545,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 +697,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 +717,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 +756,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 +786,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 +831,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 +842,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 +1076,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 +1513,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 +1565,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)) {