@reckona/mreact-router 0.0.97 → 0.0.99

package/src/bundle-pipeline.ts

@@ -12,6 +12,9 @@ import { workspacePackageFile } from "./workspace-packages.js";
 
 export interface RouterBundleOptions {
   base?: string | undefined;
+  cache?: Map<string, Promise<RouterBundleOutput>> | undefined;
+  cacheDir?: string | undefined;
+  cacheKey?: string | undefined;
   code: string;
   define?: Record<string, string> | undefined;
   dropConsoleFunctions?: readonly string[] | undefined;
@@ -22,6 +25,7 @@ export interface RouterBundleOptions {
   outfile?: string | undefined;
   platform: "browser" | "node";
   preserveExports?: boolean | undefined;
+  root?: string | undefined;
   plugins?: readonly RouterCompatPlugin[] | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
   sourceMap?: boolean | undefined;
@@ -30,9 +34,12 @@ export interface RouterBundleOptions {
 
 export interface RouterBundleModulesOptions {
   base?: string | undefined;
+  cacheDir?: string | undefined;
+  chunkFileNames?: string | undefined;
   define?: Record<string, string> | undefined;
   dropConsoleFunctions?: readonly string[] | undefined;
   entries: readonly RouterBundleEntryOptions[];
+  entryFileNames?: string | undefined;
   minify?: boolean | undefined;
   platform: "browser" | "node";
   plugins?: readonly RouterCompatPlugin[] | undefined;
@@ -130,14 +137,122 @@ export type RouterCompatResolveResult =
   | undefined;
 
 const nodeBuiltinSpecifiers = new Set(builtinModules.flatMap((name) => [name, `node:${name}`]));
+const mreactJsxRuntimeAliasPaths = new Map([
+  [
+    "react",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "index",
+      monorepoDir: "react-compat",
+      packageName: "@reckona/mreact-compat",
+    }),
+  ],
+  [
+    "react-dom",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "index",
+      monorepoDir: "react-compat",
+      packageName: "@reckona/mreact-compat",
+    }),
+  ],
+  [
+    "react-dom/client",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "index",
+      monorepoDir: "react-compat",
+      packageName: "@reckona/mreact-compat",
+    }),
+  ],
+  [
+    "react-dom/server",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "index",
+      monorepoDir: "react-compat",
+      packageName: "@reckona/mreact-compat",
+    }),
+  ],
+  [
+    "react/jsx-dev-runtime",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "jsx-dev-runtime",
+      monorepoDir: "react-compat",
+      packageName: "@reckona/mreact-compat",
+    }),
+  ],
+  [
+    "react/jsx-runtime",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "jsx-runtime",
+      monorepoDir: "react-compat",
+      packageName: "@reckona/mreact-compat",
+    }),
+  ],
+  [
+    "@reckona/mreact/jsx-dev-runtime",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "jsx-dev-runtime",
+      monorepoDir: "react",
+      packageName: "@reckona/mreact",
+    }),
+  ],
+  [
+    "@reckona/mreact/jsx-runtime",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "jsx-runtime",
+      monorepoDir: "react",
+      packageName: "@reckona/mreact",
+    }),
+  ],
+  [
+    "@reckona/mreact-compat/hooks",
+    workspacePackageFile({
+      currentFileUrl: import.meta.url,
+      entry: "hooks-entry",
+      monorepoDir: "react-compat",
+      packageName: "@reckona/mreact-compat",
+    }),
+  ],
+]);
 
 export async function bundleRouterModule(
   options: RouterBundleOptions,
+): Promise<RouterBundleOutput> {
+  if (options.cache !== undefined && options.cacheKey !== undefined) {
+    const cached = options.cache.get(options.cacheKey);
+
+    if (cached !== undefined) {
+      return cloneRouterBundleOutput(await cached);
+    }
+
+    const pending = bundleRouterModuleUncached(options);
+    options.cache.set(options.cacheKey, pending);
+
+    try {
+      return cloneRouterBundleOutput(await pending);
+    } catch (error) {
+      options.cache.delete(options.cacheKey);
+      throw error;
+    }
+  }
+
+  return await bundleRouterModuleUncached(options);
+}
+
+async function bundleRouterModuleUncached(
+  options: RouterBundleOptions,
 ): Promise<RouterBundleOutput> {
   const entryId = `${options.filename}?mreact-router-entry`;
   const outfile = options.outfile ?? "entry.js";
   const config = {
     base: options.base ?? "/",
+    ...(options.cacheDir === undefined ? {} : { cacheDir: options.cacheDir }),
     configFile: false,
     ...(options.define === undefined ? {} : { define: options.define }),
     logLevel: "silent",
@@ -157,7 +272,7 @@ export async function bundleRouterModule(
       ...(options.plugins ?? []).map(routerCompatPlugin),
     ],
     publicDir: false,
-    root: dirname(options.filename),
+    root: options.root ?? dirname(options.filename),
     ssr: {
       noExternal: true,
     },
@@ -218,6 +333,22 @@ export async function bundleRouterModule(
   };
 }
 
+function cloneRouterBundleOutput(output: RouterBundleOutput): RouterBundleOutput {
+  return {
+    ...(output.assets === undefined
+      ? {}
+      : {
+          assets: output.assets.map((asset) => ({
+            fileName: asset.fileName,
+            source:
+              typeof asset.source === "string" ? asset.source : new Uint8Array(asset.source),
+          })),
+        }),
+    code: output.code,
+    ...(output.map === undefined ? {} : { map: output.map }),
+  };
+}
+
 export async function bundleRouterModules(
   options: RouterBundleModulesOptions,
 ): Promise<RouterBundleModulesOutput> {
@@ -236,6 +367,7 @@ export async function bundleRouterModules(
   );
   const config = {
     base: options.base ?? "/",
+    ...(options.cacheDir === undefined ? {} : { cacheDir: options.cacheDir }),
     configFile: false,
     ...(options.define === undefined ? {} : { define: options.define }),
     logLevel: "silent",
@@ -262,8 +394,8 @@ export async function bundleRouterModules(
         input,
         ...routerBundleTreeshakeOptions(options.dropConsoleFunctions),
         output: {
-          chunkFileNames: "assets/chunks/[name].[hash].js",
-          entryFileNames: "assets/routes/[name].[hash].js",
+          chunkFileNames: options.chunkFileNames ?? "assets/chunks/[name].[hash].js",
+          entryFileNames: options.entryFileNames ?? "assets/routes/[name].[hash].js",
           format: "es",
           hashCharacters: "hex",
         },
@@ -315,95 +447,11 @@ export async function bundleRouterModules(
 }
 
 function mreactJsxRuntimeAliasPlugin(): VitePlugin {
-  const runtimePaths = new Map([
-    [
-      "react",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "index",
-        monorepoDir: "react-compat",
-        packageName: "@reckona/mreact-compat",
-      }),
-    ],
-    [
-      "react-dom",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "index",
-        monorepoDir: "react-compat",
-        packageName: "@reckona/mreact-compat",
-      }),
-    ],
-    [
-      "react-dom/client",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "index",
-        monorepoDir: "react-compat",
-        packageName: "@reckona/mreact-compat",
-      }),
-    ],
-    [
-      "react-dom/server",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "index",
-        monorepoDir: "react-compat",
-        packageName: "@reckona/mreact-compat",
-      }),
-    ],
-    [
-      "react/jsx-dev-runtime",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "jsx-dev-runtime",
-        monorepoDir: "react-compat",
-        packageName: "@reckona/mreact-compat",
-      }),
-    ],
-    [
-      "react/jsx-runtime",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "jsx-runtime",
-        monorepoDir: "react-compat",
-        packageName: "@reckona/mreact-compat",
-      }),
-    ],
-    [
-      "@reckona/mreact/jsx-dev-runtime",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "jsx-dev-runtime",
-        monorepoDir: "react",
-        packageName: "@reckona/mreact",
-      }),
-    ],
-    [
-      "@reckona/mreact/jsx-runtime",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "jsx-runtime",
-        monorepoDir: "react",
-        packageName: "@reckona/mreact",
-      }),
-    ],
-    [
-      "@reckona/mreact-compat/hooks",
-      workspacePackageFile({
-        currentFileUrl: import.meta.url,
-        entry: "hooks-entry",
-        monorepoDir: "react-compat",
-        packageName: "@reckona/mreact-compat",
-      }),
-    ],
-  ]);
-
   return {
     name: "mreact-router-jsx-runtime-alias",
     enforce: "pre",
     resolveId(id) {
-      return runtimePaths.get(id);
+      return mreactJsxRuntimeAliasPaths.get(id);
     },
   };
 }

package/src/cache.ts

@@ -1,3 +1,5 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
 export interface RouteCachePolicy {
   cacheControl: string;
   revalidateSeconds: number;
@@ -35,6 +37,7 @@ interface AppRouterCacheState {
   activeContexts: RouteCacheContext[];
   invalidatedPaths: Set<string>;
   memoryCache: AppRouterCache;
+  storage: AsyncLocalStorage<RouteCacheContext>;
 }
 
 interface RouteCacheContext {
@@ -49,7 +52,9 @@ const cacheState = ((
   activeContexts: [],
   invalidatedPaths: new Set(),
   memoryCache: createMemoryRouteCache(),
+  storage: new AsyncLocalStorage<RouteCacheContext>(),
 });
+cacheState.storage ??= new AsyncLocalStorage<RouteCacheContext>();
 
 export function createMemoryRouteCache(options: MemoryRouteCacheOptions = {}): AppRouterCache {
   const maxEntries = positiveIntegerOrDefault(options.maxEntries, 10_000);
@@ -188,7 +193,7 @@ export function routeCachePolicyFromSource(code: string): RouteCachePolicy | und
 }
 
 export function cacheControl(options: CacheControlOptions): void {
-  const activeContext = cacheState.activeContexts.at(-1);
+  const activeContext = activeRouteCacheContext();
 
   if (activeContext === undefined) {
     throw new Error("cacheControl() must be called during an app router request.");
@@ -291,7 +296,7 @@ export async function cacheRouteResponse(options: {
 
 export function revalidatePath(path: string): void {
   const normalizedPath = normalizeRevalidationPath(path);
-  const activeContext = cacheState.activeContexts.at(-1);
+  const activeContext = activeRouteCacheContext();
 
   if (activeContext !== undefined) {
     activeContext.revalidatedPaths.add(normalizedPath);
@@ -324,9 +329,7 @@ export async function withRouteCacheContext<T>(
     revalidatedPaths: new Set(),
   };
 
-  cacheState.activeContexts.push(context);
-
-  try {
+  return cacheState.storage.run(context, async () => {
     const value = await fn();
     const cachePolicy = context.cachePolicy;
     const revalidatedPaths = Array.from(context.revalidatedPaths);
@@ -336,9 +339,7 @@ export async function withRouteCacheContext<T>(
     }
 
     return { cachePolicy, revalidatedPaths, value };
-  } finally {
-    cacheState.activeContexts.pop();
-  }
+  });
 }
 
 export function beginRouteCacheContext(cache: AppRouterCache | undefined): {
@@ -373,6 +374,10 @@ export function beginRouteCacheContext(cache: AppRouterCache | undefined): {
   };
 }
 
+function activeRouteCacheContext(): RouteCacheContext | undefined {
+  return cacheState.storage.getStore() ?? cacheState.activeContexts.at(-1);
+}
+
 // Host is excluded from the cache key to prevent attacker-supplied Host
 // headers from fragmenting / poisoning the cache (Issue 068). The Vary
 // dimension is the request path + query; same-origin reverse proxies are

package/src/cli-options.ts

@@ -13,6 +13,7 @@ export interface ParsedCliArguments {
   command: string;
   allowedHosts?: readonly string[] | undefined;
   from?: string | undefined;
+  handler?: string | undefined;
   help?: boolean | undefined;
   host?: string | undefined;
   hostPolicy?: RequestHostPolicy | undefined;
@@ -120,6 +121,17 @@ export function parseCliArguments(argv: readonly string[]): ParsedCliArguments {
       continue;
     }
 
+    if (value === "--handler") {
+      parsed.handler = readOptionValue(argv, index, "handler");
+      index += 1;
+      continue;
+    }
+
+    if (value.startsWith("--handler=")) {
+      parsed.handler = value.slice("--handler=".length);
+      continue;
+    }
+
     if (value.startsWith("--log=")) {
       parsed.log = parseCliRequestLogMode(value.slice("--log=".length));
       continue;
@@ -202,6 +214,8 @@ export function formatCliHelp(command?: string | undefined): string {
       "  --out <dir>       Output directory. Defaults to .lambda for aws-lambda and .mreact/pages for cloudflare-pages.",
       "  --skip-runtime-dependency-check",
       "      For aws-lambda only, skip the production node_modules check when a later deploy step installs dependencies into the package directory.",
+      "  --handler <entry>",
+      "      For aws-lambda only, bundle a custom handler entry into mreact-handler.mjs. App-local extensionless TypeScript imports are bundled; package imports stay external.",
       "  -h, --help        Show this help message.",
       "",
       "Examples:",
@@ -261,6 +275,8 @@ export function formatCliHelp(command?: string | undefined): string {
     "  start [outDir]                            Serve built Node output.",
     "  package aws-lambda --from .mreact --out .lambda",
     "                                           Package a minimal AWS Lambda asset directory.",
+    "  package aws-lambda --handler lambda/mreact-handler.ts",
+    "                                           Bundle a custom Lambda handler with app-local server imports.",
     "  package cloudflare-pages --from .mreact --out .mreact/pages",
     "                                           Package Cloudflare Pages advanced mode output.",
     "  help [command]                            Show help.",
@@ -449,5 +465,9 @@ function formatCliRequestLogEvent(event: AppRouterLogEvent): string {
     return `[mreact] ${event.method} ${event.path} ${event.status} render timing`;
   }
 
+  if (event.type === "router:csp:inline-nonce-warning") {
+    return `[mreact] ${event.path} CSP ${event.directive} will block inline <${event.tag}> without a matching nonce`;
+  }
+
   return `[mreact] ${event.method} ${event.path} ${event.runtime}`;
 }

package/src/cli.ts

@@ -58,6 +58,7 @@ if (parsed !== undefined) {
         if (routeArg === "aws-lambda") {
           const manifest = await packageAwsLambdaArtifact({
             fromDir: resolve(parsed.from ?? ".mreact"),
+            ...(parsed.handler === undefined ? {} : { handlerEntry: resolve(parsed.handler) }),
             outDir: resolve(parsed.out ?? ".lambda"),
             skipRuntimeDependencyCheck: parsed.skipRuntimeDependencyCheck,
           });