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

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

@@ -81,13 +81,19 @@ function createQwikRouter(opts) {
       const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
       return new Response(notFoundHtml, {
         status: 404,
-        headers: { "Content-Type": "text/html; charset=utf-8", "X-Not-Found": url.pathname }
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "X-Not-Found": url.pathname
+        }
       });
     } catch (e) {
       console.error(e);
       return new Response(isDev ? String(e || "Error") : "Internal Server Error", {
         status: 500,
-        headers: { "Content-Type": "text/plain; charset=utf-8", "X-Error": "vercel-edge" }
+        headers: {
+          "Content-Type": "text/plain; charset=utf-8",
+          "X-Error": "vercel-edge"
+        }
       });
     }
   }

package/lib/modules.d.ts

@@ -1,15 +1,18 @@
 declare module '@qwik-router-config' {
-  export const routes: any[];
-  export const menus: any[];
+  import type { RouteData, RouteModule } from '@qwik.dev/router';
+  export const routes: RouteData;
+  export const serverPlugins: RouteModule[];
   export const trailingSlash: boolean;
   export const basePathname: string;
   export const cacheModules: boolean;
+  export const fallthrough: boolean;
   const defaultExport: {
-    routes: any[];
-    menus: any[];
+    routes: RouteData;
+    serverPlugins: RouteModule[];
     trailingSlash: boolean;
     basePathname: string;
     cacheModules: boolean;
+    fallthrough: boolean;
   };
   export default defaultExport;
 }

package/lib/ssg/index.d.ts

@@ -1,3 +1,5 @@
+import type { QwikRouterConfig } from '@qwik.dev/router';
+import type { Render } from '@qwik.dev/core/server';
 import type { RenderOptions } from '@qwik.dev/core/server';
 
 /**
@@ -6,7 +8,43 @@ import type { RenderOptions } from '@qwik.dev/core/server';
  *
  * @public
  */
-export declare function generate(opts: StaticGenerateOptions): Promise<StaticGenerateResult>;
+export declare function generate(opts: SsgInternalOptions): Promise<StaticGenerateResult>;
+
+/**
+ * Run SSG as a standalone process. Writes `_static-paths.json` to `outDir` and exits with code 0 on
+ * success, 1 on error.
+ *
+ * Intended to be called from a generated `run-ssg.js` wrapper that provides render/config.
+ *
+ * @public
+ */
+export declare function runSsg(opts: SsgInternalOptions): Promise<never>;
+
+/**
+ * Internal SSG options that include the render function and router config.
+ *
+ * @public
+ */
+export declare interface SsgInternalOptions extends SsgOptions {
+    /** The SSR render function (default export from entry.ssr). */
+    render: Render;
+    /** The Qwik Router Config object (default export from `@qwik-router-config`). */
+    qwikRouterConfig: QwikRouterConfig;
+    /**
+     * Path or URL to the worker entry file. Workers are spawned using this file. When run-ssg.js
+     * serves as both main and worker entry, this should be `import.meta.url` of that file.
+     */
+    workerFilePath?: string | URL;
+}
+
+/** @public */
+declare interface SsgOptions extends SsgRenderOptions {
+    /** Defaults to `/` */
+    basePathname?: string;
+    rootDir?: string;
+}
+export { SsgOptions }
+export { SsgOptions as StaticGenerateOptions }
 
 /** @public */
 export declare interface SsgRenderOptions extends RenderOptions {
@@ -69,21 +107,15 @@ export declare interface SsgRenderOptions extends RenderOptions {
     exclude?: string[];
 }
 
-/** @public */
-export declare interface StaticGenerateOptions extends SsgRenderOptions {
-    /**
-     * Path to the SSR module exporting the default render function. In most cases it'll be
-     * `./src/entry.ssr.tsx`.
-     */
-    renderModulePath: string;
-    /** Path to the Qwik Router Config module exporting the default `@qwik-router-config`. */
-    qwikRouterConfigModulePath: string;
-    /** @deprecated Use `qwikRouterConfigModulePath` instead. Will be removed in V3 */
-    qwikCityPlanModulePath?: string;
-    /** Defaults to `/` */
-    basePathname?: string;
-    rootDir?: string;
-}
+/**
+ * Bootstrap a worker thread for SSG rendering. Called from the generated `run-ssg.js` when it
+ * detects it's running as a worker thread.
+ *
+ * @param opts - Must include `render` and `qwikRouterConfig` (imported by the worker entry). The
+ *   remaining serializable options come from `workerData`.
+ * @public
+ */
+export declare function startWorker(opts: Pick<SsgInternalOptions, 'render' | 'qwikRouterConfig'>): Promise<void>;
 
 /** @public */
 export declare interface StaticGenerateResult {

package/lib/ssg/index.mjs

@@ -1,14 +1,327 @@
+import { bold, green, dim, red, magenta } from 'kleur/colors';
+import { relative } from 'node:path';
+import { m as msToString, g as getPathnameForDynamicRoute } from '../chunks/pathname.mjs';
+
+function routeToRegExp(rule) {
+  let transformedRule;
+  if (rule === "/" || rule === "/*") {
+    transformedRule = rule;
+  } else if (rule.endsWith("/*")) {
+    transformedRule = `${rule.substring(0, rule.length - 2)}(/*)?`;
+  } else if (rule.endsWith("/")) {
+    transformedRule = `${rule.substring(0, rule.length - 1)}(/)?`;
+  } else if (rule.endsWith("*")) {
+    transformedRule = rule;
+  } else {
+    transformedRule = `${rule}(/)?`;
+  }
+  transformedRule = `^${transformedRule.replace(/\*/g, ".*")}$`;
+  return new RegExp(transformedRule);
+}
+function routesToRegExps(routes) {
+  if (!Array.isArray(routes)) {
+    return [];
+  }
+  return routes.filter((r) => typeof r === "string").map(routeToRegExp);
+}
+function createRouteTester(basePathname, includeRoutes, excludeRoutes) {
+  const includes = routesToRegExps(includeRoutes);
+  const excludes = routesToRegExps(excludeRoutes);
+  return (pathname) => {
+    if (pathname.endsWith("404.html")) {
+      return true;
+    }
+    if (basePathname !== "/") {
+      pathname = pathname.slice(basePathname.length - 1);
+    }
+    for (const exclude of excludes) {
+      if (exclude.test(pathname)) {
+        return false;
+      }
+    }
+    for (const include of includes) {
+      if (include.test(pathname)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+
+function validateOptions(opts) {
+  if (!opts.render) {
+    throw new Error(`Missing "render" option`);
+  }
+  if (!opts.qwikRouterConfig) {
+    throw new Error(`Missing "qwikRouterConfig" option`);
+  }
+  let siteOrigin = opts.origin;
+  if (typeof siteOrigin !== "string" || siteOrigin.trim().length === 0) {
+    throw new Error(`Missing "origin" option`);
+  }
+  siteOrigin = siteOrigin.trim();
+  if (!/:\/\//.test(siteOrigin) || siteOrigin.startsWith("://")) {
+    throw new Error(`"origin" must start with a valid protocol, such as "https://" or "http://", received "${siteOrigin}"`);
+  }
+  try {
+    new URL(siteOrigin);
+  } catch (e) {
+    throw new Error(`Invalid "origin"`, {
+      cause: e
+    });
+  }
+}
+async function mainThread(sys) {
+  const opts = sys.getOptions();
+  validateOptions(opts);
+  const main = await sys.createMainProcess();
+  const log = await sys.createLogger();
+  log.info("\n" + bold(green("Starting Qwik Router SSG...")));
+  const qwikRouterConfig = opts.qwikRouterConfig;
+  const queue = [];
+  const active = /* @__PURE__ */ new Set();
+  const routes = qwikRouterConfig.routes;
+  const trailingSlash = !!qwikRouterConfig.trailingSlash;
+  const includeRoute = createRouteTester(opts.basePathname || "/", opts.include, opts.exclude);
+  return new Promise((resolve, reject) => {
+    try {
+      const timer = sys.createTimer();
+      const generatorResult = {
+        duration: 0,
+        rendered: 0,
+        errors: 0,
+        staticPaths: []
+      };
+      let isCompleted = false;
+      let isRoutesLoaded = false;
+      const completed = async () => {
+        const closePromise = main.close();
+        generatorResult.duration = timer();
+        if (generatorResult.errors === 0) {
+          log.info(`
+${green("SSG results")}`);
+          if (generatorResult.rendered > 0) {
+            log.info(`- Generated: ${dim(`${generatorResult.rendered} page${generatorResult.rendered === 1 ? "" : "s"}`)}`);
+          }
+          log.info(`- Duration: ${dim(msToString(generatorResult.duration))}`);
+          const total = generatorResult.rendered + generatorResult.errors;
+          if (total > 0) {
+            log.info(`- Average: ${dim(msToString(generatorResult.duration / total) + " per page")}`);
+          }
+          log.info(``);
+        }
+        closePromise.then(() => {
+          setTimeout(() => resolve(generatorResult));
+        }).catch(reject);
+      };
+      const next = () => {
+        while (!isCompleted && main.hasAvailableWorker() && queue.length > 0) {
+          const staticRoute = queue.shift();
+          if (staticRoute) {
+            render(staticRoute).catch((e) => {
+              console.error(`render failed for ${staticRoute.pathname}`, e);
+            });
+          }
+        }
+        if (!isCompleted && isRoutesLoaded && queue.length === 0 && active.size === 0) {
+          isCompleted = true;
+          completed().catch((e) => {
+            console.error("SSG completion failed", e);
+          });
+        }
+      };
+      let isPendingDrain = false;
+      const flushQueue = () => {
+        if (!isPendingDrain) {
+          isPendingDrain = true;
+          setTimeout(() => {
+            isPendingDrain = false;
+            next();
+          });
+        }
+      };
+      const render = async (staticRoute) => {
+        try {
+          active.add(staticRoute.pathname);
+          const result = await main.render({
+            type: "render",
+            ...staticRoute
+          });
+          active.delete(staticRoute.pathname);
+          if (result.error) {
+            const err = new Error(result.error.message);
+            err.stack = result.error.stack;
+            log.error(`
+${bold(red(`!!! ${result.pathname}: Error during SSG`))}`);
+            log.error(red(err.message));
+            log.error(`  Pathname: ${magenta(staticRoute.pathname)}`);
+            if (err.stack) {
+              log.error(dim(err.stack));
+            }
+            generatorResult.errors++;
+          }
+          if (result.filePath != null) {
+            generatorResult.rendered++;
+            generatorResult.staticPaths.push(result.pathname);
+            const base = opts.rootDir ?? opts.outDir;
+            const path = relative(base, result.filePath);
+            const lastSlash = path.lastIndexOf("/");
+            log.info(`${dim(path.slice(0, lastSlash + 1))}${path.slice(lastSlash + 1)}`);
+          }
+          flushQueue();
+        } catch (e) {
+          console.error(`render failed for ${staticRoute.pathname}`, e);
+          isCompleted = true;
+          reject(e);
+        }
+      };
+      const addToQueue = (pathname, params) => {
+        if (pathname) {
+          pathname = new URL(pathname, `https://qwik.dev`).pathname;
+          if (pathname !== opts.basePathname) {
+            if (trailingSlash) {
+              if (!pathname.endsWith("/")) {
+                const segments = pathname.split("/");
+                const lastSegment = segments[segments.length - 1];
+                if (!lastSegment.includes(".")) {
+                  pathname += "/";
+                }
+              }
+            } else {
+              if (pathname.endsWith("/")) {
+                pathname = pathname.slice(0, pathname.length - 1);
+              }
+            }
+          }
+          if (includeRoute(pathname) && !queue.some((s) => s.pathname === pathname)) {
+            queue.push({
+              pathname,
+              params
+            });
+            flushQueue();
+          }
+        }
+      };
+      const traverseRouteTree = async (node, pathParts, basePathname, ancestorLoaders) => {
+        const currentLoaders = node._L ? [
+          ...ancestorLoaders,
+          node._L
+        ] : ancestorLoaders;
+        const index = node._I;
+        if (index) {
+          const pageLoaders = Array.isArray(index) ? index : [
+            ...currentLoaders,
+            index
+          ];
+          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 (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) {
+          for (const group of node._M) {
+            await traverseRouteTree(group, pathParts, basePathname, currentLoaders);
+          }
+        }
+        if (node._W && typeof node._W === "object") {
+          const childNode = node._W;
+          const paramName = childNode._P;
+          const pathPart = paramName ? `[${paramName}]` : "[param]";
+          await traverseRouteTree(childNode, [
+            ...pathParts,
+            pathPart
+          ], basePathname, currentLoaders);
+        }
+        if (node._A && typeof node._A === "object") {
+          const childNode = node._A;
+          const paramName = childNode._P;
+          const pathPart = paramName ? `[...${paramName}]` : "[...rest]";
+          await traverseRouteTree(childNode, [
+            ...pathParts,
+            pathPart
+          ], basePathname, currentLoaders);
+        }
+        for (const [key, child] of Object.entries(node)) {
+          if (key.charCodeAt(0) === 95) {
+            continue;
+          }
+          const childNode = child;
+          await traverseRouteTree(childNode, [
+            ...pathParts,
+            key
+          ], basePathname, currentLoaders);
+        }
+      };
+      const loadStaticRoutes = async () => {
+        const basePathname = opts.basePathname || "/";
+        await traverseRouteTree(routes, [], basePathname, []);
+        isRoutesLoaded = true;
+        flushQueue();
+      };
+      loadStaticRoutes().catch((e) => {
+        console.error("SSG route loading failed", e);
+        reject(e);
+      });
+    } catch (e) {
+      console.error("SSG main thread failed", e);
+      reject(e);
+    }
+  });
+}
+
 async function generate(opts) {
-  const ssgPlatform = await getEntryModule();
-  const result = await ssgPlatform.generate(opts);
-  return result;
+  const { createSystem } = await import('../chunks/system.mjs');
+  const sys = await createSystem(opts);
+  return mainThread(sys);
 }
-async function getEntryModule() {
+async function runSsg(opts) {
   try {
-    return await import('../chunks/index.mjs');
+    const result = await generate(opts);
+    const fs = await import('node:fs');
+    const { join } = await import('node:path');
+    const staticPathsFile = join(opts.outDir, "_static-paths.json");
+    await fs.promises.writeFile(staticPathsFile, JSON.stringify(result.staticPaths));
+    if (result.errors > 0) {
+      console.error(`SSG completed with ${result.errors} error(s)`);
+      process.exit(1);
+    }
+    process.exit(0);
   } catch (e) {
-    throw new Error(`Unsupported platform`, { cause: e });
+    console.error("SSG failed:", e);
+    process.exit(1);
   }
 }
+async function startWorker(opts) {
+  const { workerData } = await import('node:worker_threads');
+  const mergedOpts = {
+    ...workerData,
+    render: opts.render,
+    qwikRouterConfig: opts.qwikRouterConfig
+  };
+  const { createSystem } = await import('../chunks/system.mjs');
+  const { workerThread } = await import('../chunks/worker-thread.mjs');
+  const sys = await createSystem(mergedOpts, workerData?.threadId);
+  await workerThread(sys);
+}
 
-export { generate };
+export { generate, runSsg, startWorker };

package/lib/vite/index.d.ts

@@ -165,6 +165,12 @@ export declare interface QwikRouterVitePluginOptions extends Omit<PluginOptions,
      * Default: true
      */
     devSsrServer?: boolean;
+    /**
+     * Maximum number of SSR-rendered pages to keep in the in-memory cache. Set to 0 to disable.
+     *
+     * Default: 50
+     */
+    ssrCacheSize?: number;
 }
 
 /** @public */