@qwik.dev/router 2.0.0-beta.29 → 2.0.0-beta.30

package/lib/middleware/vercel-edge/index.mjs

@@ -68,9 +68,9 @@ function createQwikRouter(opts) {
       };
       const handledResponse = await requestHandler(serverRequestEv, opts);
       if (handledResponse) {
-        handledResponse.completion.then((v) => {
-          if (v) {
-            console.error(v);
+        handledResponse.completion.then((completion) => {
+          if (completion) {
+            console.error(completion);
           }
         });
         const response = await handledResponse.response;

package/lib/ssg/index.d.ts

@@ -75,8 +75,8 @@ export declare interface SsgRenderOptions extends RenderOptions {
      * root of the `outDir`. Setting to `null` will prevent the sitemap from being created.
      */
     sitemapOutFile?: string | null;
-    /** Log level. */
-    log?: 'debug';
+    /** Log level. `'quiet'` suppresses per-page output, `'debug'` enables verbose logging. */
+    log?: 'debug' | 'quiet';
     /**
      * Set to `false` if the generated static HTML files should not be written to disk. Setting to
      * `false` is useful if the SSG should only write the `q-data.json` files to disk. Defaults to

package/lib/ssg/index.mjs

@@ -78,6 +78,7 @@ async function mainThread(sys) {
   const log = await sys.createLogger();
   log.info("\n" + bold(green("Starting Qwik Router SSG...")));
   const qwikRouterConfig = opts.qwikRouterConfig;
+  const renderTimeout = 3e4;
   const queue = [];
   const active = /* @__PURE__ */ new Set();
   const routes = qwikRouterConfig.routes;
@@ -143,11 +144,16 @@ ${green("SSG results")}`);
       const render = async (staticRoute) => {
         try {
           active.add(staticRoute.pathname);
-          const result = await main.render({
-            type: "render",
-            ...staticRoute
-          });
+          log.debug(`render start: ${staticRoute.pathname}`);
+          const result = await Promise.race([
+            main.render({
+              type: "render",
+              ...staticRoute
+            }),
+            new Promise((_, reject2) => setTimeout(() => reject2(new Error(`SSG render timed out after ${renderTimeout}ms`)), renderTimeout))
+          ]);
           active.delete(staticRoute.pathname);
+          log.debug(`render done: ${staticRoute.pathname}`);
           if (result.error) {
             const err = new Error(result.error.message);
             err.stack = result.error.stack;
@@ -216,26 +222,28 @@ ${bold(red(`!!! ${result.pathname}: Error during SSG`))}`);
           const joinedParts = pathParts.join("/");
           const originalPathname = basePathname + (joinedParts ? joinedParts + "/" : "");
           const paramNames = pathParts.filter((p) => p.startsWith("[") && p.endsWith("]")).map((p) => p.startsWith("[...") ? p.slice(4, -1) : p.slice(1, -1));
-          const modules = await Promise.all(pageLoaders.filter((l) => typeof l === "function").map((l) => l()));
-          const pageModule = modules[modules.length - 1];
-          if (paramNames.length > 0) {
-            if (typeof pageModule.onStaticGenerate === "function") {
-              const staticGenerate = await pageModule.onStaticGenerate({
-                env: {
-                  get(key) {
-                    return sys.getEnv(key);
+          if (paramNames.length === 0) {
+            addToQueue(originalPathname, void 0);
+          } else {
+            const pageLoader = pageLoaders[pageLoaders.length - 1];
+            if (typeof pageLoader === "function") {
+              const pageModule = await pageLoader();
+              if (typeof pageModule.onStaticGenerate === "function") {
+                const staticGenerate = await pageModule.onStaticGenerate({
+                  env: {
+                    get(key) {
+                      return sys.getEnv(key);
+                    }
+                  }
+                });
+                if (Array.isArray(staticGenerate.params)) {
+                  for (const params of staticGenerate.params) {
+                    const pathname = getPathnameForDynamicRoute(originalPathname, paramNames, params);
+                    addToQueue(pathname, params);
                   }
-                }
-              });
-              if (Array.isArray(staticGenerate.params)) {
-                for (const params of staticGenerate.params) {
-                  const pathname = getPathnameForDynamicRoute(originalPathname, paramNames, params);
-                  addToQueue(pathname, params);
                 }
               }
             }
-          } else {
-            addToQueue(originalPathname, void 0);
           }
         }
         if (node._M) {
@@ -273,8 +281,9 @@ ${bold(red(`!!! ${result.pathname}: Error during SSG`))}`);
         }
       };
       const loadStaticRoutes = async () => {
-        const basePathname = opts.basePathname || "/";
-        await traverseRouteTree(routes, [], basePathname, []);
+        log.debug("traversing route tree...");
+        await traverseRouteTree(routes, [], "/", []);
+        log.debug(`route tree traversed, ${queue.length} routes queued, ${active.size} active`);
         isRoutesLoaded = true;
         flushQueue();
       };
@@ -319,7 +328,7 @@ async function startWorker(opts) {
     qwikRouterConfig: opts.qwikRouterConfig
   };
   const { createSystem } = await import('../chunks/system.mjs');
-  const { workerThread } = await import('../chunks/worker-thread.mjs');
+  const { workerThread } = await import('../chunks/worker-thread.qwik.mjs');
   const sys = await createSystem(mergedOpts, workerData?.threadId);
   await workerThread(sys);
 }

package/lib/vite/index.mjs

@@ -638,9 +638,97 @@ function rewriteRoutes(ctx, routes) {
   });
   return translatedRoutes.sort(routeSortCompare);
 }
+function applyRewriteRoutes(root, rewriteConfigs) {
+  const routables = [];
+  function walk(node, steps) {
+    const hasRoute = node._files.some((f) => f.type === "route" && f.extlessName !== "error" && f.extlessName !== "404");
+    if (hasRoute) {
+      routables.push({
+        steps: [
+          ...steps
+        ],
+        node
+      });
+    }
+    for (const [key, child] of node.children) {
+      const isGroup = key.startsWith("(") && key.endsWith(")");
+      if (isGroup) {
+        walk(child, steps);
+      } else {
+        walk(child, [
+          ...steps,
+          {
+            key,
+            paramName: child._P,
+            prefix: child._0,
+            suffix: child._9
+          }
+        ]);
+      }
+    }
+  }
+  walk(root, []);
+  for (const config of rewriteConfigs) {
+    const translations = config.paths || {};
+    const translatable = new Set(Object.keys(translations).map((k) => k.toLowerCase()));
+    for (const { steps } of routables) {
+      const hasTranslatable = steps.some((s) => translatable.has(s.key));
+      if (!hasTranslatable && !config.prefix) {
+        continue;
+      }
+      if (steps.length === 0 && !config.prefix) {
+        continue;
+      }
+      const originalKeyPath = steps.map((s) => s.key).join("/");
+      const translatedSteps = [];
+      if (config.prefix) {
+        translatedSteps.push({
+          key: config.prefix.toLowerCase()
+        });
+      }
+      for (const step of steps) {
+        const translated = translations[step.key];
+        translatedSteps.push({
+          ...step,
+          key: translated ? translated.toLowerCase() : step.key
+        });
+      }
+      const translatedKeyPath = translatedSteps.map((s) => s.key).join("/");
+      if (translatedKeyPath === originalKeyPath) {
+        continue;
+      }
+      let current = root;
+      for (const step of translatedSteps) {
+        let child = current.children.get(step.key);
+        if (!child) {
+          child = {
+            _files: [],
+            _dirPath: "",
+            children: /* @__PURE__ */ new Map()
+          };
+          if (step.paramName) {
+            child._P = step.paramName;
+          }
+          if (step.prefix) {
+            child._0 = step.prefix;
+          }
+          if (step.suffix) {
+            child._9 = step.suffix;
+          }
+          current.children.set(step.key, child);
+        }
+        current = child;
+      }
+      current._G = originalKeyPath;
+    }
+  }
+}
 async function _updateRoutingContext(ctx) {
   const serverPlugins = await walkServerPlugins(ctx.opts);
   const routeTrie = await walkRoutes(ctx.opts.routesDir);
+  if (ctx.opts.rewriteRoutes) {
+    applyRewriteRoutes(routeTrie, ctx.opts.rewriteRoutes);
+  }
   ctx.routeTrie = routeTrie;
   ctx.serverPlugins = serverPlugins;
   const derived = deriveFromTrie(ctx.opts, routeTrie);
@@ -1486,6 +1574,9 @@ function generateQwikRouterConfig(ctx, qwikPlugin, isSSR) {
 /** Qwik Router Config */`);
   c.push(`
 import { isDev } from '@qwik.dev/core/build';`);
+  if (isSSR) {
+    esmImports.push(`import 'virtual:qwik-router-server-fns';`);
+  }
   createServerPlugins(ctx, qwikPlugin, c, esmImports, isSSR);
   createRoutes(ctx, qwikPlugin, c, esmImports, isSSR);
   createEntries(ctx, c);
@@ -1736,7 +1827,7 @@ function imagePlugin(userOpts) {
     ".tiff"
   ];
   return [
-    import('vite-imagetools').then(({ imagetools }) => imagetools({
+    import('vite-imagetools').then((_rawProps) => _rawProps.imagetools({
       exclude: [],
       extendOutputFormats(builtins) {
         const jsx = () => (metadatas) => {
@@ -2176,6 +2267,7 @@ const QWIK_ROUTER_CONFIG_ID = "@qwik-router-config";
 const QWIK_ROUTER_ENTRIES_ID = "@qwik-router-entries";
 const QWIK_ROUTER = "@qwik.dev/router";
 const QWIK_ROUTER_SW_REGISTER = "@qwik-router-sw-register";
+const VIRTUAL_SERVER_FNS = "virtual:qwik-router-server-fns";
 async function generateServerPackageJson(outDir) {
   await fs.promises.mkdir(outDir, {
     recursive: true
@@ -2381,7 +2473,7 @@ function qwikRouterPlugin(userOpts) {
       }
       return null;
     },
-    async load(id, opts) {
+    async load(id) {
       if (ctx) {
         if (id.endsWith(QWIK_ROUTER_ENTRIES_ID)) {
           return generateQwikRouterEntries(ctx);
@@ -2486,9 +2578,77 @@ function qwikRouterPlugin(userOpts) {
   };
   return plugin;
 }
+function serverFnsPlugin() {
+  const RESOLVED_ID = "\0" + VIRTUAL_SERVER_FNS;
+  const serverFnModules = /* @__PURE__ */ new Set();
+  let pendingModules = 0;
+  let resolveServerFns = null;
+  let serverFnsReady;
+  function reset() {
+    serverFnModules.clear();
+    pendingModules = 0;
+    serverFnsReady = new Promise((r) => {
+      resolveServerFns = r;
+    });
+  }
+  reset();
+  return {
+    name: "vite-plugin-qwik-router-server-fns",
+    buildStart() {
+      reset();
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_SERVER_FNS) {
+        return {
+          id: RESOLVED_ID,
+          moduleSideEffects: "no-treeshake"
+        };
+      }
+    },
+    load: {
+      order: "pre",
+      async handler(id) {
+        const isServerBuild = this.environment.config.consumer === "server" && this.environment.mode === "build";
+        if (id === RESOLVED_ID) {
+          if (isServerBuild) {
+            await serverFnsReady;
+          }
+          if (!isServerBuild || serverFnModules.size === 0) {
+            return "// No server$ functions";
+          }
+          return [
+            ...serverFnModules
+          ].map((mod) => `import ${JSON.stringify(mod)};`).join("\n");
+        }
+        if (isServerBuild && id !== RESOLVED_ID) {
+          pendingModules++;
+          this.load({
+            id
+          }).then((result) => {
+            if (typeof result.code === "string" && result.code.includes("serverQrl(")) {
+              serverFnModules.add(id);
+            }
+          }).finally(() => {
+            pendingModules--;
+            if (pendingModules <= 0 && resolveServerFns) {
+              setTimeout(() => {
+                if (pendingModules <= 0 && resolveServerFns) {
+                  resolveServerFns();
+                  resolveServerFns = null;
+                }
+              }, 50);
+            }
+          });
+        }
+        return null;
+      }
+    }
+  };
+}
 function qwikRouter(userOpts) {
   return [
     qwikRouterPlugin(userOpts),
+    serverFnsPlugin(),
     ...imagePlugin(userOpts)
   ];
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@qwik.dev/router",
   "description": "The router for Qwik.",
-  "version": "2.0.0-beta.29",
+  "version": "2.0.0-beta.30",
   "bugs": "https://github.com/QwikDev/qwik/issues",
   "dependencies": {
     "@azure/functions": "3.5.1",
     "@mdx-js/mdx": "^3.1.1",
-    "@netlify/edge-functions": "^2.17.0",
+    "@netlify/edge-functions": "^3.0.6",
     "@types/mdx": "^2.0.13",
     "estree-util-value-to-estree": "^3.5.0",
     "github-slugger": "^2.0.0",
@@ -40,7 +40,7 @@
     "tsm": "2.3.0",
     "typescript": "5.9.3",
     "uvu": "0.5.6",
-    "@qwik.dev/core": "2.0.0-beta.29"
+    "@qwik.dev/core": "2.0.0-beta.30"
   },
   "engines": {
     "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
@@ -169,7 +169,7 @@
   "main": "./lib/index.qwik.mjs",
   "peerDependencies": {
     "vite": ">=6 <9",
-    "@qwik.dev/core": "^2.0.0-beta.29"
+    "@qwik.dev/core": "^2.0.0-beta.30"
   },
   "publishConfig": {
     "access": "public"

package/lib/chunks/worker-thread.mjs

@@ -1,271 +0,0 @@
-import { _serialize } from '@qwik.dev/core/internal';
-import { RequestEvShareQData, requestHandler, RedirectMessage } from '@qwik.dev/router/middleware/request-handler';
-import { parentPort } from 'node:worker_threads';
-
-const createNoopWritableStream = () => new WritableStream();
-async function workerRender(sys, opts, staticRoute, pendingPromises, callback) {
-  const url = new URL(staticRoute.pathname, opts.origin);
-  const result = {
-    type: "render",
-    pathname: staticRoute.pathname,
-    url: url.href,
-    ok: false,
-    error: null,
-    filePath: null,
-    contentType: null,
-    resourceType: null
-  };
-  try {
-    let routeWriter = null;
-    let closeResolved;
-    const closePromise = new Promise((closePromiseResolve) => {
-      closeResolved = closePromiseResolve;
-    });
-    const request = new Request(url);
-    const requestCtx = {
-      mode: "static",
-      locale: void 0,
-      url,
-      request,
-      env: {
-        get(key) {
-          return sys.getEnv(key);
-        }
-      },
-      platform: sys.platform,
-      getClientConn: () => {
-        return {};
-      },
-      getWritableStream: (status, headers, _, _r, requestEv) => {
-        result.ok = status >= 200 && status < 300;
-        if (!result.ok) {
-          return createNoopWritableStream();
-        }
-        result.contentType = (headers.get("Content-Type") || "").toLowerCase();
-        const isHtml = result.contentType.includes("text/html");
-        const is404ErrorPage = url.pathname.endsWith("/404.html");
-        const routeFilePath = sys.getRouteFilePath(url.pathname, isHtml);
-        if (is404ErrorPage) {
-          result.resourceType = "404";
-        } else if (isHtml) {
-          result.resourceType = "page";
-        }
-        const hasRouteWriter = isHtml ? opts.emitHtml !== false : true;
-        const writeQDataEnabled = isHtml && opts.emitData !== false;
-        const stream = new WritableStream({
-          async start() {
-            try {
-              if (hasRouteWriter || writeQDataEnabled) {
-                await sys.ensureDir(routeFilePath);
-              }
-              if (hasRouteWriter) {
-                routeWriter = sys.createWriteStream(routeFilePath);
-                routeWriter.on("error", (e) => {
-                  console.error(e);
-                  routeWriter = null;
-                  result.error = {
-                    message: e.message,
-                    stack: e.stack
-                  };
-                });
-              }
-            } catch (e) {
-              console.error("Error during stream start", staticRoute.pathname, e);
-              routeWriter = null;
-              result.error = {
-                message: String(e),
-                stack: e.stack || ""
-              };
-            }
-          },
-          write(chunk) {
-            try {
-              if (routeWriter) {
-                routeWriter.write(Buffer.from(chunk.buffer));
-              }
-            } catch (e) {
-              console.error("Error during stream write", staticRoute.pathname, e);
-              routeWriter = null;
-              result.error = {
-                message: String(e),
-                stack: e.stack || ""
-              };
-            }
-          },
-          async close() {
-            const writePromises = [];
-            try {
-              if (writeQDataEnabled) {
-                const qData = requestEv.sharedMap.get(RequestEvShareQData);
-                if (qData && !is404ErrorPage) {
-                  const qDataFilePath = sys.getDataFilePath(url.pathname);
-                  const dataWriter = sys.createWriteStream(qDataFilePath);
-                  dataWriter.on("error", (e) => {
-                    console.error(e);
-                    result.error = {
-                      message: e.message,
-                      stack: e.stack
-                    };
-                  });
-                  const serialized = await _serialize(qData);
-                  dataWriter.write(serialized);
-                  writePromises.push(new Promise((resolve) => {
-                    result.filePath = routeFilePath;
-                    dataWriter.end(resolve);
-                  }));
-                }
-              }
-              if (routeWriter) {
-                writePromises.push(new Promise((resolve) => {
-                  result.filePath = routeFilePath;
-                  routeWriter.end(resolve);
-                }).finally(closeResolved));
-              }
-              if (writePromises.length > 0) {
-                await Promise.all(writePromises);
-              }
-            } catch (e) {
-              console.error("Error during stream close", staticRoute.pathname, e);
-              routeWriter = null;
-              result.error = {
-                message: String(e),
-                stack: e.stack || ""
-              };
-            }
-          }
-        });
-        return stream;
-      }
-    };
-    const promise = requestHandler(requestCtx, opts).then((rsp) => {
-      if (rsp != null) {
-        return rsp.completion.then((r) => {
-          if (routeWriter) {
-            return closePromise.then(() => r);
-          }
-          return r;
-        });
-      }
-    }).then((e) => {
-      if (e !== void 0) {
-        if (e instanceof RedirectMessage) {
-          return;
-        }
-        if (e instanceof Error) {
-          result.error = {
-            message: e.message,
-            stack: e.stack
-          };
-        } else {
-          result.error = {
-            message: String(e),
-            stack: void 0
-          };
-        }
-        console.error("Error during request handling", staticRoute.pathname, e);
-      }
-    }).catch((e) => {
-      console.error("Unhandled error during request handling", staticRoute.pathname, e);
-      result.error = {
-        message: String(e),
-        stack: e.stack || ""
-      };
-    }).finally(() => {
-      pendingPromises.delete(promise);
-      callback(result);
-    });
-    pendingPromises.add(promise);
-  } catch (e) {
-    console.error("Error during render", staticRoute.pathname, e);
-    if (e instanceof Error) {
-      result.error = {
-        message: e.message,
-        stack: e.stack
-      };
-    } else {
-      result.error = {
-        message: String(e),
-        stack: void 0
-      };
-    }
-    callback(result);
-  }
-}
-async function workerThread(sys) {
-  delete globalThis.__qwik;
-  const opts = sys.getOptions();
-  const pendingPromises = /* @__PURE__ */ new Set();
-  const log = await sys.createLogger();
-  process.on("uncaughtException", (e) => {
-    console.error("Worker uncaught exception (suppressed):", e.message);
-  });
-  process.on("unhandledRejection", (e) => {
-    console.error("Worker unhandled rejection (suppressed):", e instanceof Error ? e.message : e);
-  });
-  const onMessage = async (msg) => {
-    switch (msg.type) {
-      case "render": {
-        log.debug(`Worker thread rendering: ${msg.pathname}`);
-        return new Promise((resolve) => {
-          workerRender(sys, opts, msg, pendingPromises, resolve).catch((e) => {
-            console.error("Error during render", msg.pathname, e);
-            resolve({
-              type: "render",
-              pathname: msg.pathname,
-              url: "",
-              ok: false,
-              error: {
-                message: e instanceof Error ? e.message : String(e),
-                stack: e instanceof Error ? e.stack : void 0
-              },
-              filePath: null,
-              contentType: null,
-              resourceType: null
-            });
-          });
-        });
-      }
-      case "close": {
-        if (pendingPromises.size) {
-          log.debug(`Worker thread closing, waiting for ${pendingPromises.size} pending renders`);
-          const promises = Array.from(pendingPromises);
-          pendingPromises.clear();
-          await Promise.all(promises);
-        }
-        log.debug(`Worker thread closed`);
-        return {
-          type: "close"
-        };
-      }
-    }
-  };
-  parentPort?.on("message", async (msg) => {
-    try {
-      parentPort?.postMessage(await onMessage(msg));
-    } catch (e) {
-      if (msg.type === "render") {
-        const error = e instanceof Error ? e : new Error(String(e));
-        parentPort?.postMessage({
-          type: "render",
-          pathname: msg.pathname,
-          url: "",
-          ok: false,
-          error: {
-            message: error.message,
-            stack: error.stack
-          },
-          filePath: null,
-          contentType: null,
-          resourceType: null
-        });
-      } else {
-        console.error("Worker message handler error", e);
-      }
-    }
-    if (msg.type === "close") {
-      parentPort?.close();
-    }
-  });
-}
-
-export { workerThread };