vite-plugin-vanjs 0.1.25 → 0.2.1

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "vite-plugin-vanjs",
-  "version": "0.1.25",
+  "version": "0.2.1",
   "author": "thednp",
   "license": "MIT",
   "description": "An async first mini meta-framework for VanJS powered by Vite",
-  "repository": "https://github.com/thednp/vite-plugin-vanjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thednp/vite-plugin-vanjs"
+  },
   "type": "module",
   "sideEffects": false,
   "main": "./plugin/index.mjs",
@@ -84,26 +87,23 @@
   "dependencies": {
     "csstype": "^3.2.3",
     "mini-van-plate": "^0.6.3",
-    "vanjs-core": "^1.6.0",
+    "vanjs-core": "^1.6.1",
     "vanjs-ext": "^0.6.3"
   },
   "devDependencies": {
-    "@types/node": "^25.9.3",
-    "@vitest/browser": "^4.1.8",
-    "@vitest/coverage-istanbul": "^4.1.8",
-    "@vitest/ui": "^4.1.8",
-    "happy-dom": "^20.10.3",
-    "typescript": "6.0.3",
-    "vite": "^8.0.16",
-    "vitest": "^4.1.8"
-  },
-  "engines": {
-    "node": ">=20",
-    "pnpm": ">=8.6.0"
+    "@types/node": "^26.5.1",
+    "@vitest/browser": "^5.0.1",
+    "@vitest/coverage-istanbul": "^5.0.1",
+    "@vitest/ui": "^5.0.1",
+    "happy-dom": "^20.14.5",
+    "typescript": "7.0.2",
+    "vite": "^8.3.0",
+    "vitest": "^5.0.1"
   },
   "scripts": {
-    "test": "vitest --config vitest.config.ts",
-    "test-ui": "vitest --config vitest.config.ts --ui=true",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest --coverage",
+    "test:ui": "vitest --config --ui=true",
     "format": "deno fmt plugin meta router setup client server jsx",
     "lint": "pnpm lint:ts && pnpm check:ts",
     "lint:ts": "deno lint plugin meta router setup client server jsx",

package/plugin/helpers.mjs

@@ -16,10 +16,11 @@ import process from "node:process";
 export const fileToRoute = (file, routesDir) => {
   const cleanPath = file
     .slice(routesDir.length + 1) // also remove initial slash
+    .replace(/\\/g, "/") // normalize Windows backslashes to forward slashes
     .replace(/\.(jsx|tsx|ts|js)$/, "")
     .replace(/index$/, "")
-    .replace(/\(.*\)$/, "") // Remove (file_name) from path
-    .replace(/\([^)]+\)\/?/g, "") // Remove (folder_name) from path
+    .replace(/\([^()]*\)$/, "") // Remove (file_name) from path
+    .replace(/\([^()]+\)\/?/g, "") // Remove (folder_name) from path
     .replace(/\[\.\.\.[^\]]+\]/g, "*")
     .replace(/\[([^\]]+)\]/g, ":$1");
   const slashPath = cleanPath.endsWith("/")
@@ -136,7 +137,7 @@ export const findLayouts = (routePath, config, pluginConfig) => {
   const { routesDir, extensions } = pluginConfig;
   const layouts = [];
   let dir = dirname(routePath);
-  const routesPath = join(config.root, routesDir);
+  const routesPath = normalizePath(join(config.root, routesDir));
 
   // Walk up the directory tree looking for layout files
   while (dir.startsWith(routesPath) && dir !== routesPath) { // Stop at routes dir
@@ -148,8 +149,13 @@ export const findLayouts = (routePath, config, pluginConfig) => {
       // Look for a layout file in the current directory
       for (const ext of extensions) {
         const layoutPaths = [
-          join(dirname(dir), `${dirName}${ext}`),
-          join(dirname(dir), `(${dirName.replace(/^\((.*)\)$/, "$1")})${ext}`),
+          normalizePath(join(dirname(dir), `${dirName}${ext}`)),
+          normalizePath(
+            join(
+              dirname(dir),
+              `(${dirName.replace(/^\((.*)\)$/, "$1")})${ext}`,
+            ),
+          ),
         ];
 
         for (const path of layoutPaths) {
@@ -162,10 +168,10 @@ export const findLayouts = (routePath, config, pluginConfig) => {
     }
 
     // istanbul ignore else
-    if (layoutFile && layoutFile !== routePath) {
+    if (layoutFile && normalizePath(layoutFile) !== routePath) {
       layouts.unshift({
         id: `Layout${layouts.length}`,
-        path: layoutFile,
+        path: normalizePath(layoutFile),
       });
     }
 
@@ -246,17 +252,24 @@ load: async (params) => {
 /** @type {(route: RouteFile) => string} */
 export const generateComponentRoute = (route) => {
   if (route.layouts?.length > 0) {
-    // Only generate imports for unique layouts
     const layoutImports = route.layouts.map(
       (layout) =>
         `const ${layout.id}Module = await import('${layout.path}');\n` +
         `const ${layout.id}Page = ${layout.id}Module.Layout || ${layout.id}Module.Page || ${layout.id}Module.default;`,
     ).join("\n");
 
-    // Use both shared and unique layouts for the component chain
-    const pageComponent = route.layouts.reduce(
+    const layoutsArray = `[${
+      route.layouts.map(
+        (layout) =>
+          `{ path: ${
+            JSON.stringify(layout.path)
+          }, component: ${layout.id}Page }`,
+      ).join(", ")
+    }]`;
+
+    const chainBuild = route.layouts.reduceRight(
       (acc, layout) => `${layout.id}Page({ children: ${acc} })`,
-      "Page()",
+      "leaf()",
     );
 
     return `lazy(() => {
@@ -264,10 +277,15 @@ export const generateComponentRoute = (route) => {
         ${layoutImports}
         const PageModule = await import('${route.path}');
         const Page = PageModule?.Page || PageModule?.default;
+        const layouts = ${layoutsArray};
+        const leaf = () => Page();
+        const component = () => ${chainBuild};
   
         return Promise.resolve({
           route: ${generateRouteProloaders(route)},
-          Page: () => ${pageComponent},
+          component,
+          layouts,
+          leaf,
         });
       };
       return importFn();

package/router/a.mjs

@@ -41,7 +41,7 @@ export const A = (
 
       navigate(HREF);
     },
-    onmouseenter: async () => {
+    onmouseenter: async (e) => {
       const HREF = getValue(href);
       const route = matchRoute(HREF);
 

package/router/dataCache.mjs

@@ -27,6 +27,7 @@ const evictIfNeeded = () => {
   if (maxRoutes <= 0) return;
   while (dataCacheMap.size > maxRoutes) {
     const firstKey = dataCacheMap.keys().next().value;
+    /* istanbul ignore else - the map is guaranteed to have entries here */
     if (firstKey !== undefined) {
       dataCacheMap.delete(firstKey);
     }

package/router/global.d.ts

@@ -119,6 +119,12 @@ declare module "@vanjs/router" {
    */
   export const getValue: (v: unknown) => string;
 
+  /**
+   * Build the data cache key for the current route, based on the
+   * current route params and the current search params.
+   */
+  export const getCacheKey: () => string;
+
   /**
    * Check if selected page is the current page
    */
@@ -253,14 +259,23 @@ declare module "@vanjs/router" {
   export type ComponentModule = {
     component: ComponentFn;
     route?: Pick<RouteEntry, "load" | "preload">;
+    layouts?: RouteLayout[];
+    leaf?: ComponentFn;
   };
 
   export type LazyComponent = Promise<{
     default?: ComponentFn;
     Page?: ComponentFn;
     route?: Pick<RouteEntry, "load" | "preload">;
+    layouts?: RouteLayout[];
+    leaf?: ComponentFn;
   }>;
 
+  export type RouteLayout = {
+    path: string;
+    component: ComponentFn;
+  };
+
   /**
    * Registers a lazy component.
    * @param importFn
@@ -290,6 +305,30 @@ declare module "@vanjs/router" {
     } | null,
   ) => Promise<boolean>;
 
+  /**
+   * Resolve a route component, execute its lifecycle methods and render
+   * the resulting children into the given wrapper.
+   * @param route the matched route
+   * @param wrapper the element that hosts the route children
+   * @param ssr when true the children are appended instead of replaced
+   */
+  export const executeModule: (
+    route: RouteEntry,
+    wrapper: HTMLElement,
+    ssr?: boolean,
+  ) => Promise<HTMLElement | void>;
+
+  /**
+   * Resolve the children of a component module, an element or an array of elements.
+   */
+  export const resolveChildren: (
+    module:
+      | ComponentModule
+      | VanElement
+      | VanElement[]
+      | { component?: ComponentFn | VanElement },
+  ) => VanNode[];
+
   /**
    * Find a registered route that matches the given path
    */

package/router/helpers.mjs

@@ -148,9 +148,9 @@ export const executeLifecycle = async (route) => {
  * @returns
  */
 export const executeModule = async (route, wrapper, ssr) => {
-  if (routerState.loading === true) return;
+  if (routerState._oldVal.loading === true) return;
   // 0. Set Loading State
-  routerState.loading = true;
+  routerState._oldVal.loading = true;
   try {
     // 1. Resolve the module first (to get route lifecycle hooks)
     const module = await route.component();
@@ -165,7 +165,7 @@ export const executeModule = async (route, wrapper, ssr) => {
     else wrapper.replaceChildren(...children);
   } finally {
     // 5. Set Loading State
-    routerState.loading = false;
+    routerState._oldVal.loading = false;
   }
 };
 

package/router/lazy.mjs

@@ -21,9 +21,14 @@ export const lazy = (importFn) => {
 
     const module = await importFn();
     /** @type {ComponentFn} */
-    const component = module?.default || module.Page;
+    const component = module?.default || module.Page || module.component;
     /** @type {ComponentModule} */
-    const result = { component, route: module.route };
+    const result = {
+      component,
+      route: module.route,
+      layouts: module.layouts,
+      leaf: module.leaf,
+    };
 
     cacheRoute(importFn, result);
     return result;

package/router/router.mjs

@@ -3,8 +3,14 @@ import isServer from "../setup/isServer.mjs";
 import { MODE } from "../plugin/const.mjs";
 import { routerState, setRouterState } from "./state.mjs";
 import { matchRoute } from "./matchRoute.mjs";
-import { executeModule } from "./helpers.mjs";
+import {
+  executeLifecycle,
+  executeModule,
+  resolveChildren,
+} from "./helpers.mjs";
 import { initializeHeadTags } from "../meta/index.mjs";
+import { hydrate } from "../client/index.mjs";
+import { Head } from "../meta/index.mjs";
 import * as dataCache from "./dataCache.mjs";
 import "virtual:@vanjs/routes";
 
@@ -13,6 +19,7 @@ const isDev = MODE === "development";
 /** @typedef {import("./types.d.ts").ComponentModule} ComponentModule */
 /** @typedef {import("./types.d.ts").RouteEntry} RouteEntry */
 /** @typedef {import("./types.d.ts").VanNode} VanNode */
+/** @typedef {import("./types.d.ts").RouteLayout} RouteLayout */
 
 /**
  * Initialize client-side router (Head + popstate listener)
@@ -40,32 +47,79 @@ const initClient = () => {
   _initialized = true;
 };
 
+/**
+ * Build the layout chain + leaf into DOM nodes.
+ * @param {{ layouts?: RouteLayout[], leaf?: () => any }} mod
+ * @param {HTMLElement} outlet
+ * @returns {import("@vanjs/router").DOMElement[]}
+ */
+const buildChain = (mod, outlet) => {
+  const chain = mod.layouts ?? /* istanbul ignore next */ [];
+  const leafFn = mod.leaf;
+
+  if (chain.length === 0) {
+    const nodes = leafFn ? leafFn() : /* istanbul ignore next */ [];
+    /* istanbul ignore next */
+    return Array.isArray(nodes) ? nodes : [nodes];
+  }
+
+  // Fill the outlet with the leaf content
+  const leafContent = leafFn ? leafFn() : /* istanbul ignore next */ [];
+  /* istanbul ignore else */
+  if (Array.isArray(leafContent)) {
+    outlet.replaceChildren(...leafContent);
+  } else {
+    outlet.replaceChildren(leafContent);
+  }
+
+  // Build outside-in: outermost layout wraps innermost → ... → leaf outlet
+  let content = [outlet];
+  for (let k = chain.length - 1; k >= 0; k--) {
+    content = chain[k].component({ children: content });
+    /* istanbul ignore else */
+    if (!Array.isArray(content)) content = [content];
+  }
+
+  return content;
+};
+
 export const Router = (initialProps = /* istanbul ignore next */ {}) => {
   const { div, main } = van.tags;
   const props = Object.fromEntries(
     Object.entries(initialProps).filter(([_, val]) => val !== undefined),
   );
   const wrapper = main({ ...props, "data-root": "" });
-  const route = matchRoute(routerState.pathname);
-  let _searchParams = routerState.searchParams;
+  // Read the initial route without subscribing: Router() is typically
+  // invoked inside a reactive context (e.g. hydrate(main, App)), and a
+  // reactive read here would re-create the whole Router on every
+  // navigation. Only the internal derive below subscribes, to pathname
+  // and searchParams.
+  const route = matchRoute(routerState._oldVal.pathname);
+  let _searchParams = routerState._oldVal.searchParams;
 
   /* istanbul ignore else */
   if (!route) return van.add(wrapper, div("No Route Found"));
   // It's important to READ the params
   Object.assign(routerState.params, route.params);
 
-  // Server-side rendering
+  // Server-side rendering — single-pass full render in one shot.
+  // No reactivity and no shared loading flag: concurrent requests share
+  // the routerState singleton, so the client-side loading guard would
+  // wrongly bail out with `undefined` on overlapping requests.
   if (isServer) {
-    return async () => {
+    return (async () => {
       try {
-        return await executeModule(route, wrapper, true);
+        const module = await route.component();
+        await executeLifecycle(Object.assign(route, module.route));
+        const children = resolveChildren(module);
+        return van.add(wrapper, ...children);
       } catch (error) {
         /* istanbul ignore next */
         console.error("Router error:", error);
         /* istanbul ignore next */
         return van.add(wrapper, div("Error loading page"));
       }
-    };
+    })();
   }
 
   // Init client here
@@ -79,31 +133,119 @@ export const Router = (initialProps = /* istanbul ignore next */ {}) => {
     dataCache.hydrateFromJSON(globalThis.__DATA_CACHE);
   }
 
+  // Persistent layout chain keys for prefix-diff tracking (client only)
+  /** @type {string[]} */
+  let layoutKeys = [];
+  /** @type {HTMLElement | null} */
+  let outlet = null;
+  let navToken = 0;
+  // Live DOM target for client-side navigations. On the hydration path this
+  // starts as the detached wrapper (used for the initial render that hydrate()
+  // diffs into the SSR root) and is adopted to the real root once the initial
+  // render completes. On the SPA path it stays the wrapper, which is live.
+  /** @type {any} */
+  let liveTarget = wrapper;
+
+  /**
+   * Navigate to a new route, rendering the layout chain.
+   * Uses prefix-diff to detect shared layouts and only rebuilds the diverged suffix.
+   * @param {{ layouts?: RouteLayout[], leaf?: () => any }} mod
+   */
+  const navigateToModule = (mod) => {
+    const newKeys = (mod.layouts ?? /* istanbul ignore next */ []).map((l) =>
+      l.path
+    );
+
+    // Find shared prefix length
+    let keepCount = 0;
+    while (
+      keepCount < layoutKeys.length && keepCount < newKeys.length &&
+      layoutKeys[keepCount] === newKeys[keepCount]
+    ) {
+      keepCount++;
+    }
+
+    layoutKeys = newKeys;
+
+    if (keepCount > 0 && keepCount === layoutKeys.length && outlet) {
+      // All layouts shared — only the leaf changed.
+      // Directly swap the outlet's children; layout DOM is untouched.
+      const leafFn = mod.leaf;
+      const leafContent = leafFn ? leafFn() : /* istanbul ignore next */ [];
+      /* istanbul ignore else */
+      if (Array.isArray(leafContent)) {
+        outlet.replaceChildren(...leafContent);
+      } else {
+        outlet.replaceChildren(leafContent);
+      }
+    } else {
+      // Diverged layout chain — full rebuild with a fresh outlet.
+      const div = van.tags.div;
+      outlet = div();
+      const children = buildChain(mod, outlet);
+      liveTarget.replaceChildren(...children);
+    }
+  };
+
   // Client-side: check if hydrating SSR content or pure SPA
   const root = document.querySelector("[data-root]");
 
   if (root) {
     van.derive(() => {
+      // Subscribe to pathname AND searchParams: either one triggers a
+      // navigation (e.g. search-only changes keep the same pathname).
+      // VanJS batches the synchronous writes from setRouterState into a
+      // single run, and same-value writes don't re-trigger at all.
+      // Everything else is read via _oldVal to avoid extra runs.
+      const pathname = routerState.pathname;
+      _searchParams = routerState.searchParams;
       if (!initialized) return;
-      const matchedRoute = matchRoute(routerState.pathname);
+      const matchedRoute = matchRoute(pathname);
       if (!matchedRoute) {
-        wrapper.replaceChildren(div("No Route Found"));
+        liveTarget.replaceChildren(div("No Route Found"));
         return;
       }
       (async () => {
-        _searchParams = routerState.searchParams;
-        await executeModule(matchedRoute, wrapper);
+        const token = ++navToken;
+        routerState._oldVal.loading = true;
+        try {
+          const module = await matchedRoute.component();
+          /* istanbul ignore next */
+          if (token !== navToken) return;
+          await executeLifecycle(Object.assign(matchedRoute, module.route));
+          // A newer navigation may have started during the (possibly slow)
+          // lifecycle: never render stale results over fresh ones.
+          if (token !== navToken) return;
+          /* istanbul ignore else */
+          if (document.head) hydrate(document.head, Head());
+          if (module.layouts) {
+            navigateToModule(module);
+          } else {
+            layoutKeys = [];
+            outlet = null;
+            const children = resolveChildren(module);
+            liveTarget.replaceChildren(...children);
+          }
+        } finally {
+          routerState._oldVal.loading = false;
+        }
       })();
     });
     return async () => {
       const result = await executeModule(route, wrapper, true);
+      // Adopt the live SSR root: subsequent navigations mutate the real DOM,
+      // not the detached wrapper used for the initial render.
+      liveTarget = root;
       initialized = true;
       return result;
     };
   }
 
-  // Pure SPA path - reactive routing
+  // Pure SPA path - reactive routing.
+  // Subscribed to pathname and searchParams (batched into a single run);
+  // everything else goes through _oldVal.
   van.derive(() => {
+    _searchParams = routerState.searchParams;
     const matchedRoute = matchRoute(routerState.pathname);
     if (!matchedRoute) {
       wrapper.replaceChildren(div("No Route Found"));
@@ -111,8 +253,31 @@ export const Router = (initialProps = /* istanbul ignore next */ {}) => {
     }
 
     (async () => {
-      _searchParams = routerState.searchParams;
-      await executeModule(matchedRoute, wrapper);
+      const token = ++navToken;
+      // routerState._oldVal.loading = true;
+      routerState.loading = true;
+      try {
+        _searchParams = routerState.searchParams;
+        const module = await matchedRoute.component();
+        if (token !== navToken) return;
+        await executeLifecycle(Object.assign(matchedRoute, module.route));
+        // A newer navigation may have started during the (possibly slow)
+        // lifecycle: never render stale results over fresh ones.
+        if (token !== navToken) return;
+        /* istanbul ignore else */
+        if (document.head) hydrate(document.head, Head());
+        if (module.layouts) {
+          navigateToModule(module);
+        } else {
+          layoutKeys = [];
+          outlet = null;
+          const children = resolveChildren(module);
+          wrapper.replaceChildren(...children);
+        }
+      } finally {
+        // routerState._oldVal.loading = false;
+        routerState.loading = false;
+      }
     })();
   });
 

package/router/state.mjs

@@ -42,7 +42,7 @@ const proxyProps = {
  * @param {Record<string, string | number>} target
  * @returns {T}
  */
-const defineProxy = (key, value, target) => {
+const defineProxy = (key, value, target, oldVal) => {
   const stateObj = van.state(value);
 
   const getter = () => stateObj.val;
@@ -51,6 +51,9 @@ const defineProxy = (key, value, target) => {
   };
   stateObj.val = value;
 
+  const hasOwnRawVal = Object.getOwnPropertyDescriptor(stateObj, "rawVal")
+    ?.writable;
+
   Object.defineProperties(target, {
     [STATE_PROXY]: proxyProps,
     [key]: {
@@ -60,7 +63,14 @@ const defineProxy = (key, value, target) => {
     },
   });
 
-  return stateObj;
+  Object.defineProperty(oldVal, key, {
+    get: () => stateObj.rawVal,
+    set: (v) => {
+      if (hasOwnRawVal) stateObj.rawVal = v;
+      else stateObj.val = v;
+    },
+    enumerable: true,
+  });
 };
 
 /** @typedef  */
@@ -73,22 +83,34 @@ const defineProxy = (key, value, target) => {
 export function microStore(init) {
   /** @type {T} */
   const target = {};
+  /** @type {Record<string, unknown>} */
+  const oldVal = {};
   for (const [prop, value] of Object.entries(init)) {
     const isPlainObject = value && typeof value === "object" &&
-      !Array.isArray(value) && Object.getPrototypeOf(value) === Object;
+      !Array.isArray(value) &&
+      Object.getPrototypeOf(value) === Object.prototype;
 
     if (isPlainObject && Object.keys(value).length > 0) {
+      /** @type {Record<string, string | number>} */
+      const nested = {};
       for (const [sp, sv] of Object.entries(value)) {
-        target[prop] = defineProxy(sp, sv, {});
+        defineProxy(sp, sv, nested, oldVal);
       }
+      defineProxy(prop, nested, target, oldVal);
     } else if (isPlainObject) {
-      defineProxy(prop, value, target);
+      defineProxy(prop, value, target, oldVal);
     } else if (!Array.isArray(value) && value != null) {
-      defineProxy(prop, value, target);
+      defineProxy(prop, value, target, oldVal);
     } else {
       console.warn(typeof value + " is not supported.");
     }
   }
+
+  Object.defineProperty(target, "_oldVal", {
+    get: () => oldVal,
+    enumerable: false,
+  });
+
   return target;
 }
 

package/router/types.d.ts

@@ -75,6 +75,12 @@ export const redirect: (href?: string) => void | (() => void);
 
 export const getValue: (v: unknown) => string;
 
+/**
+ * Build the data cache key for the current route, based on the
+ * current route params and the current search params.
+ */
+export const getCacheKey: () => string;
+
 export const isCurrentPage: (pageName: string) => boolean;
 
 export const isCurrentLocation: (pageName: string) => boolean;
@@ -88,6 +94,30 @@ export const executeLifecycle: (
   } | null,
 ) => Promise<boolean>;
 
+/**
+ * Resolve a route component, execute its lifecycle methods and render
+ * the resulting children into the given wrapper.
+ * @param route the matched route
+ * @param wrapper the element that hosts the route children
+ * @param ssr when true the children are appended instead of replaced
+ */
+export const executeModule: (
+  route: RouteEntry,
+  wrapper: HTMLElement,
+  ssr?: boolean,
+) => Promise<HTMLElement | void>;
+
+/**
+ * Resolve the children of a component module, an element or an array of elements.
+ */
+export const resolveChildren: (
+  module:
+    | ComponentModule
+    | VanElement
+    | VanElement[]
+    | { component?: ComponentFn | VanElement },
+) => VanNode[];
+
 export const useRouteData: <T>() => T | undefined;
 
 export const matchRoute: (path: string) => RouteEntry | null;
@@ -190,14 +220,23 @@ export type ComponentFn = FragmentFn | VanComponent | JSXComponentFn;
 export type ComponentModule = {
   component: ComponentFn;
   route?: Pick<RouteEntry, "load" | "preload">;
+  layouts?: RouteLayout[];
+  leaf?: ComponentFn;
 };
 
 export type LazyComponent = Promise<{
   default?: ComponentFn;
   Page?: ComponentFn;
   route?: Pick<RouteEntry, "load" | "preload">;
+  layouts?: RouteLayout[];
+  leaf?: ComponentFn;
 }>;
 
+export type RouteLayout = {
+  path: string;
+  component: ComponentFn;
+};
+
 // dataCache.mjs
 export type CacheEntry<T = unknown> = {
   data: T;

package/server/types.d.ts

@@ -38,6 +38,13 @@ export type Source =
  */
 export const renderToString: (source: Source) => Promise<string>;
 
+/**
+ * A function that generates a <script> for initial hydration data.
+ * Serializes the full path-keyed data cache into window.__DATA_CACHE.
+ * @returns HTML string
+ */
+export const getDataPreload: () => string;
+
 // FILE SYSTEM ROUTER
 /**
  * Get the file most probable route path for a given potential route.
@@ -47,7 +54,14 @@ export const fileToRoute: (file: string, routesDir: string) => string;
 export type PageFile = { path: string; routePath: string };
 export type LayoutFile = { id: string; path: string };
 export type RouteFile = PageFile & { layouts: Array<LayoutFile> };
-export type PluginConfig = { routesDir: string; extensions: string[] };
+export type PluginConfig = {
+  routesDir: string;
+  extensions: string[];
+  /** route paths excluded in all environments */
+  excludeRoutes?: string[];
+  /** route paths excluded in production only */
+  excludeRoutesProd?: string[];
+};
 /**
  * Find all layout files for a given route.
  */

package/tsconfig.json

@@ -35,5 +35,5 @@
     "./server/*.ts",
     "./client/*.ts",
   ],
-  "exclude": ["node_modules", "experiments", "coverage"],
+  "exclude": ["node_modules", "experiments", "coverage", "tests"],
 }