@qwik.dev/router 2.0.0-beta.3 → 2.0.0-beta.31

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

@@ -1,27 +1,14 @@
-// packages/qwik-router/src/middleware/vercel-edge/index.ts
-import { getNotFound } from "@qwik-router-not-found-paths";
-import { isStaticPath } from "@qwik-router-static-paths";
-import { _deserialize, _serialize, _verifySerializable } from "@qwik.dev/core/internal";
-import { setServerPlatform } from "@qwik.dev/core/server";
-import { mergeHeadersCookies, requestHandler } from "../request-handler/index.mjs";
-var COUNTRY_HEADER_NAME = "x-vercel-ip-country";
-var IP_HEADER_NAME = "x-real-ip";
-var VERCEL_COOKIE = "__vdpl";
-var VERCEL_SKEW_PROTECTION_ENABLED = "VERCEL_SKEW_PROTECTION_ENABLED";
-var VERCEL_DEPLOYMENT_ID = "VERCEL_DEPLOYMENT_ID";
-var BASE_URL = "BASE_URL";
+import { setServerPlatform } from '@qwik.dev/core/server';
+import { isStaticPath, mergeHeadersCookies, requestHandler, getNotFound } from '@qwik.dev/router/middleware/request-handler';
+import { isDev } from '@qwik.dev/core/build';
+
+const COUNTRY_HEADER_NAME = "x-vercel-ip-country";
+const IP_HEADER_NAME = "x-real-ip";
+const VERCEL_COOKIE = "__vdpl";
+const VERCEL_SKEW_PROTECTION_ENABLED = "VERCEL_SKEW_PROTECTION_ENABLED";
+const VERCEL_DEPLOYMENT_ID = "VERCEL_DEPLOYMENT_ID";
+const BASE_URL = "BASE_URL";
 function createQwikRouter(opts) {
-  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
-    console.warn("qwikCityPlan is deprecated. Use qwikRouterConfig instead.");
-    opts.qwikRouterConfig = opts.qwikCityPlan;
-  } else if (!opts.qwikRouterConfig) {
-    throw new Error("qwikRouterConfig is required.");
-  }
-  const qwikSerializer = {
-    _deserialize,
-    _serialize,
-    _verifySerializable
-  };
   if (opts.manifest) {
     setServerPlatform(opts.manifest);
   }
@@ -75,11 +62,11 @@ function createQwikRouter(opts) {
           };
         }
       };
-      const handledResponse = await requestHandler(serverRequestEv, opts, qwikSerializer);
+      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;
@@ -87,23 +74,27 @@ function createQwikRouter(opts) {
           return response;
         }
       }
-      const notFoundHtml = isStaticPath(request.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
+      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(String(e || "Error"), {
+      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"
+        }
       });
     }
   }
   return onVercelEdgeRequest;
 }
-var createQwikCity = createQwikRouter;
-export {
-  createQwikCity,
-  createQwikRouter
-};
+const createQwikCity = createQwikRouter;
+
+export { createQwikCity, createQwikRouter };

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;
 }
@@ -19,20 +22,12 @@ declare module '@qwik-city-plan' {
   export { default } from '@qwik-router-config';
 }
 
-declare module '@qwik-router-not-found-paths' {
-  function getNotFound(_pathname: string): string;
-  export { getNotFound };
-}
-
 declare module '@qwik-city-not-found-paths' {
-  export * from '@qwik-router-not-found-paths';
-}
-
-declare module '@qwik-router-static-paths' {
-  function isStaticPath(method: string, url: URL): boolean;
-  export { isStaticPath };
+  /** @deprecated Use `getNotFound` from `@qwik.dev/router/middleware/request-handler` instead. */
+  export { getNotFound } from '@qwik.dev/router/middleware/request-handler';
 }
 
 declare module '@qwik-city-static-paths' {
-  export * from '@qwik-router-static-paths';
+  /** @deprecated Use `isStaticPath` from `@qwik.dev/router/middleware/request-handler` instead. */
+  export { isStaticPath } from '@qwik.dev/router/middleware/request-handler';
 }

package/lib/service-worker/index.mjs

@@ -0,0 +1,4 @@
+const setupServiceWorker = () => {
+};
+
+export { setupServiceWorker };

package/lib/{static → 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,26 +8,46 @@ 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>;
 
-/** @public */
-export declare interface StaticGenerateOptions extends StaticGenerateRenderOptions {
+/**
+ * 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 to the SSR module exporting the default render function. In most cases it'll be
-     * `./src/entry.ssr.tsx`.
+     * 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.
      */
-    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;
+    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 StaticGenerateRenderOptions extends RenderOptions {
+export declare interface SsgRenderOptions extends RenderOptions {
     /** File system directory where the static files should be written. */
     outDir: string;
     /**
@@ -53,8 +75,8 @@ export declare interface StaticGenerateRenderOptions 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
@@ -85,6 +107,16 @@ export declare interface StaticGenerateRenderOptions extends RenderOptions {
     exclude?: 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 {
     duration: number;

package/lib/ssg/index.mjs

@@ -0,0 +1,336 @@
+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 renderTimeout = 3e4;
+  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);
+          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;
+            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));
+          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 (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 () => {
+        log.debug("traversing route tree...");
+        await traverseRouteTree(routes, [], "/", []);
+        log.debug(`route tree traversed, ${queue.length} routes queued, ${active.size} active`);
+        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 { createSystem } = await import('../chunks/system.mjs');
+  const sys = await createSystem(opts);
+  return mainThread(sys);
+}
+async function runSsg(opts) {
+  try {
+    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) {
+    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.qwik.mjs');
+  const sys = await createSystem(mergedOpts, workerData?.threadId);
+  await workerThread(sys);
+}
+
+export { generate, runSsg, startWorker };

package/lib/vite/index.d.ts

@@ -4,15 +4,16 @@ import type { Config } from 'svgo';
 import { ConfigEnv } from 'vite';
 import type { Plugin as Plugin_2 } from 'vite';
 import type { PluginOption } from 'vite';
+import type { SerializationStrategy } from '@qwik.dev/core/internal';
 import { UserConfigExport } from 'vite';
 
-declare interface BuildEntry extends ParsedPathname {
+declare interface BuiltEntry extends ParsedPathname {
     id: string;
     chunkFileName: string;
     filePath: string;
 }
 
-declare interface BuildLayout {
+declare interface BuiltLayout {
     filePath: string;
     dirPath: string;
     id: string;
@@ -20,7 +21,7 @@ declare interface BuildLayout {
     layoutName: string;
 }
 
-declare interface BuildRoute extends ParsedPathname {
+declare interface BuiltRoute extends ParsedPathname {
     /** Unique id built from its relative file system path */
     id: string;
     /** Local file system path */
@@ -28,7 +29,7 @@ declare interface BuildRoute extends ParsedPathname {
     ext: string;
     /** URL Pathname */
     pathname: string;
-    layouts: BuildLayout[];
+    layouts: BuiltLayout[];
 }
 
 /** @public */
@@ -80,13 +81,13 @@ declare interface PathnameSegmentPart {
 
 /** @public */
 declare interface PluginOptions {
-    /** Directory of the `routes`. Defaults to `src/routes`. */
+    /** Directory of the `routes`. Defaults to `"src/routes"`. */
     routesDir?: string;
-    /** Directory of the `server plugins`. Defaults to `src/server-plugins`. */
+    /** Directory of the `server plugins`. Defaults to `routesDir`. */
     serverPluginsDir?: string;
     /**
      * The base pathname is used to create absolute URL paths up to the `hostname`, and must always
-     * start and end with a `/`. Defaults to `/`.
+     * start and end with a `/`. Defaults to `"/""`.
      */
     basePathname?: string;
     /**
@@ -98,10 +99,18 @@ declare interface PluginOptions {
     mdxPlugins?: MdxPlugins;
     /** MDX Options https://mdxjs.com/ */
     mdx?: any;
-    /** The platform object which can be used to mock the Cloudflare bindings. */
+    /**
+     * Extend the `platform` object in RequestEvent, which can be used to e.g. mock Cloudflare
+     * bindings.
+     *
+     * This only works in **dev mode** and only when using the in-process Vite dev server middleware
+     * (the default).
+     */
     platform?: Record<string, unknown>;
     /** Configuration to rewrite url paths */
     rewriteRoutes?: RewriteRouteOption[];
+    /** The serialization strategy for route loaders. Defaults to `never`. */
+    defaultLoadersSerializationStrategy?: SerializationStrategy;
 }
 
 /**
@@ -133,8 +142,8 @@ export declare interface QwikRouterPlugin extends P<QwikRouterPluginApi> {
 /** @public */
 declare interface QwikRouterPluginApi {
     getBasePathname: () => string;
-    getRoutes: () => BuildRoute[];
-    getServiceWorkers: () => BuildEntry[];
+    getRoutes: () => BuiltRoute[];
+    getServiceWorkers: () => BuiltEntry[];
 }
 
 /** @public */
@@ -143,6 +152,25 @@ export declare interface QwikRouterVitePluginOptions extends Omit<PluginOptions,
     mdx?: MdxOptions;
     platform?: Record<string, unknown>;
     imageOptimization?: ImageOptimizationOptions;
+    /** Whether to use static imports for route modules (layout and index files). Defaults to `false`. */
+    staticImportRoutes?: boolean;
+    /**
+     * Qwik is an SSR first framework. This means that Qwik requires either SSR or SSG. In Vite dev
+     * mode the dev SSR server is responsible for rendering and pausing the application on the
+     * server.
+     *
+     * Under normal circumstances this should be on, unless you have your own dev SSR server setup and
+     * wish to disable this one.
+     *
+     * 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 */