vike-lite 1.15.13 → 1.15.15

package/dist/__internal/client.d.mts

@@ -1,7 +1,10 @@
+import { t as VikeState } from "../store-9UNcAe5D.mjs";
 //#region src/__internal/client.d.ts
 declare function createLinkClickHandler(onNavigate: (url: URL) => void): (e: MouseEvent) => void;
 declare function createLinkPrefetchHandler(onPrefetch: (url: URL) => void): (e: Event) => void;
-declare function finalizeNavigation(scrollStateSetState: boolean): void;
+declare function finalizeNavigation(shouldScrollToTop: {
+  current: boolean;
+}): void;
 interface ViewComponents {
   Page: any | null;
   Layout: any | null;
@@ -49,5 +52,37 @@ declare function createRoutePrefetcher(): (route: PrefetchableRoute) => void;
  * Returns true if a reload was triggered — the caller should stop further error handling.
  */
 declare function tryRecoverFromStaleModuleGraph(message: string, urlToReload: string): boolean;
+/**
+ * Stamp the client-only flags that every `PageContextClient` requires (`isClientSide`,
+ * `isHydration`) onto the raw context blob the server injected via `window.__PAGE_CONTEXT__`.
+ * Centralized so every adapter sets these consistently instead of some silently omitting them.
+ */
+declare function buildInitialClientContext<T extends Record<string, any>>(rawContext: T | undefined, isHydration: boolean): T & {
+  isClientSide: true;
+  isHydration: boolean;
+};
+interface HydrationInitialContext {
+  urlPathname?: string;
+  is404?: boolean;
+  is500?: boolean;
+  errorMessage?: string;
+}
+/**
+ * Resolve the Page/Layout/Head modules to hydrate with, matching what the server
+ * actually rendered into the HTML: the error route's modules when the server
+ * reported a 404/500/error, otherwise the modules of the route matching the
+ * initial pathname. Returns a null view when hydration isn't happening (client
+ * takeover) — the router's own first-load effect performs the initial load instead.
+ */
+declare function resolveHydrationView(initialContext: HydrationInitialContext, isHydration: boolean, routes: VikeState['routes'], errorRoute: VikeState['errorRoute']): Promise<ViewComponents>;
+/**
+ * Consume the server-injected initial context if it still matches the given pathname
+ * (i.e. this is the very first client-side route load, right after SSR hydration/render).
+ * Clears the global reference so a later remount at the same pathname (e.g. React
+ * StrictMode double-invoke in dev) triggers a real fetch instead of being mistaken
+ * for the original initial load. Returns true if consumed — the caller should skip
+ * loading for this run.
+ */
+declare function consumeMatchingInitialContext(pathname: string): boolean;
 //#endregion
-export { ViewComponents, buildPageContextJsonUrl, createLinkClickHandler, createLinkPrefetchHandler, createRoutePrefetcher, fetchPageContextJson, finalizeNavigation, loadViewModules, tryRecoverFromStaleModuleGraph };
+export { ViewComponents, buildInitialClientContext, buildPageContextJsonUrl, consumeMatchingInitialContext, createLinkClickHandler, createLinkPrefetchHandler, createRoutePrefetcher, fetchPageContextJson, finalizeNavigation, loadViewModules, resolveHydrationView, tryRecoverFromStaleModuleGraph };

package/dist/__internal/client.mjs

@@ -1,4 +1,4 @@
-import { BASE_URL } from "./shared.mjs";
+import { BASE_URL, matchRoute } from "./shared.mjs";
 //#region src/__internal/client.ts
 function getClientSideUrl(target) {
 	if (!target?.href || target.target && target.target !== "_self" || target.hasAttribute("download") || target.hasAttribute("data-native") || target.getAttribute("rel")?.includes("external")) return null;
@@ -15,7 +15,7 @@ function isSamePage(url) {
 }
 function createLinkClickHandler(onNavigate) {
 	return (e) => {
-		if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+		if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || !(e.target instanceof Element)) return;
 		const url = getClientSideUrl(e.target.closest("a"));
 		if (!url || isSamePage(url)) return;
 		e.preventDefault();
@@ -25,15 +25,16 @@ function createLinkClickHandler(onNavigate) {
 }
 function createLinkPrefetchHandler(onPrefetch) {
 	return (e) => {
+		if (!(e.target instanceof Element)) return;
 		const url = getClientSideUrl(e.target.closest("a"));
 		if (!url || isSamePage(url)) return;
 		onPrefetch(url);
 	};
 }
-function finalizeNavigation(scrollStateSetState) {
-	if (scrollStateSetState) {
+function finalizeNavigation(shouldScrollToTop) {
+	if (shouldScrollToTop.current) {
 		globalThis.scrollTo(0, 0);
-		scrollStateSetState = false;
+		shouldScrollToTop.current = false;
 	} else if (globalThis.location.hash) requestAnimationFrame(() => {
 		try {
 			document.querySelector(decodeURIComponent(globalThis.location.hash))?.scrollIntoView();
@@ -111,5 +112,48 @@ function tryRecoverFromStaleModuleGraph(message, urlToReload) {
 	globalThis.location.assign(urlToReload);
 	return true;
 }
+/**
+* Stamp the client-only flags that every `PageContextClient` requires (`isClientSide`,
+* `isHydration`) onto the raw context blob the server injected via `window.__PAGE_CONTEXT__`.
+* Centralized so every adapter sets these consistently instead of some silently omitting them.
+*/
+function buildInitialClientContext(rawContext, isHydration) {
+	return {
+		...rawContext ?? {},
+		isClientSide: true,
+		isHydration
+	};
+}
+/**
+* Resolve the Page/Layout/Head modules to hydrate with, matching what the server
+* actually rendered into the HTML: the error route's modules when the server
+* reported a 404/500/error, otherwise the modules of the route matching the
+* initial pathname. Returns a null view when hydration isn't happening (client
+* takeover) — the router's own first-load effect performs the initial load instead.
+*/
+async function resolveHydrationView(initialContext, isHydration, routes, errorRoute) {
+	const emptyView = {
+		Page: null,
+		Layout: null,
+		Head: null
+	};
+	if (!isHydration) return emptyView;
+	if ((initialContext.is404 || initialContext.is500 || initialContext.errorMessage) && errorRoute) return loadViewModules(errorRoute);
+	const matched = matchRoute(initialContext.urlPathname ?? globalThis.location.pathname, routes);
+	return matched ? loadViewModules(matched.route) : emptyView;
+}
+/**
+* Consume the server-injected initial context if it still matches the given pathname
+* (i.e. this is the very first client-side route load, right after SSR hydration/render).
+* Clears the global reference so a later remount at the same pathname (e.g. React
+* StrictMode double-invoke in dev) triggers a real fetch instead of being mistaken
+* for the original initial load. Returns true if consumed — the caller should skip
+* loading for this run.
+*/
+function consumeMatchingInitialContext(pathname) {
+	if (globalThis.__PAGE_CONTEXT__?.urlPathname !== pathname) return false;
+	globalThis.__PAGE_CONTEXT__ = void 0;
+	return true;
+}
 //#endregion
-export { buildPageContextJsonUrl, createLinkClickHandler, createLinkPrefetchHandler, createRoutePrefetcher, fetchPageContextJson, finalizeNavigation, loadViewModules, tryRecoverFromStaleModuleGraph };
+export { buildInitialClientContext, buildPageContextJsonUrl, consumeMatchingInitialContext, createLinkClickHandler, createLinkPrefetchHandler, createRoutePrefetcher, fetchPageContextJson, finalizeNavigation, loadViewModules, resolveHydrationView, tryRecoverFromStaleModuleGraph };

package/dist/__internal/server.d.mts

@@ -1,11 +1,2 @@
-//#region src/server/store.d.ts
-interface VikeState {
-  routes: typeof import('virtual:vike-lite/routes')['routes'] | [];
-  errorRoute: typeof import('virtual:vike-lite/routes')['errorRoute'] | null;
-  config: typeof import('virtual:vike-lite/routes')['config'] | null;
-  manifest: typeof import('virtual:vike-lite/client-manifest')['default'] | null;
-}
-declare const store: VikeState;
-declare function setVikeState(newState: Partial<VikeState>): void;
-//#endregion
+import { n as setVikeState, r as store, t as VikeState } from "../store-9UNcAe5D.mjs";
 export { VikeState, setVikeState, store };

package/dist/__internal/vite.d.mts

@@ -1,5 +1,25 @@
 import { Plugin } from "vite";
 //#region src/__internal/vite.d.ts
+/**
+ * Creates the Vite plugin that configures dev-server pre-bundling and SSR externalization
+ * for framework adapters (e.g. vike-lite-solid, vike-lite-vue) that export raw, uncompiled
+ * source files (.tsx/.vue) instead of a pre-built dist. Those adapters need:
+ *  - `optimizeDeps.include`: eagerly pre-bundle the framework runtime (e.g. `solid-js`, `vue`)
+ *    so the dev server doesn't re-bundle it on every page navigation.
+ *  - `optimizeDeps.exclude` + `ssr.noExternal`: prevent Vite from treating the adapter package
+ *    as an opaque, externalizable dependency, so its raw JSX/SFC source is instead processed
+ *    by the framework's own Vite plugin (e.g. vite-plugin-solid, @vitejs/plugin-vue) both in
+ *    dev and during the SSR build.
+ *
+ * This centralizes logic that is otherwise identical across every `vike-lite-*` package
+ * that ships raw source files.
+ */
+declare function createDepsConfigPlugin({ packageName, optimizeDepsInclude }: {
+  /** The framework adapter's package name, e.g. 'vike-lite-solid'. */
+  packageName: string;
+  /** Framework runtime packages to eagerly pre-bundle, e.g. ['solid-js']. */
+  optimizeDepsInclude: string[];
+}): Plugin;
 /**
  * Creates the Vite plugin that wires a UI framework adapter (react/vue/solid) into vike-lite,
  * by providing the virtual `virtual:vike-lite/client` and `virtual:vike-lite/server` modules
@@ -16,4 +36,4 @@ declare function createFrameworkAdapterPlugin({ packageName, hydration, wrapServ
   wrapServerHydration?: boolean;
 }): Plugin;
 //#endregion
-export { createFrameworkAdapterPlugin };
+export { createDepsConfigPlugin, createFrameworkAdapterPlugin };

package/dist/__internal/vite.mjs

@@ -1,5 +1,34 @@
 //#region src/__internal/vite.ts
 /**
+* Creates the Vite plugin that configures dev-server pre-bundling and SSR externalization
+* for framework adapters (e.g. vike-lite-solid, vike-lite-vue) that export raw, uncompiled
+* source files (.tsx/.vue) instead of a pre-built dist. Those adapters need:
+*  - `optimizeDeps.include`: eagerly pre-bundle the framework runtime (e.g. `solid-js`, `vue`)
+*    so the dev server doesn't re-bundle it on every page navigation.
+*  - `optimizeDeps.exclude` + `ssr.noExternal`: prevent Vite from treating the adapter package
+*    as an opaque, externalizable dependency, so its raw JSX/SFC source is instead processed
+*    by the framework's own Vite plugin (e.g. vite-plugin-solid, @vitejs/plugin-vue) both in
+*    dev and during the SSR build.
+*
+* This centralizes logic that is otherwise identical across every `vike-lite-*` package
+* that ships raw source files.
+*/
+function createDepsConfigPlugin({ packageName, optimizeDepsInclude }) {
+	return {
+		name: `${packageName}-config`,
+		enforce: "pre",
+		config() {
+			return {
+				optimizeDeps: {
+					include: optimizeDepsInclude,
+					exclude: [packageName]
+				},
+				ssr: { noExternal: [packageName] }
+			};
+		}
+	};
+}
+/**
 * Creates the Vite plugin that wires a UI framework adapter (react/vue/solid) into vike-lite,
 * by providing the virtual `virtual:vike-lite/client` and `virtual:vike-lite/server` modules
 * that vike-lite's core plugin reads to discover the framework's onRenderClient/onRenderHtml hooks.
@@ -25,4 +54,4 @@ function createFrameworkAdapterPlugin({ packageName, hydration = true, wrapServe
 	};
 }
 //#endregion
-export { createFrameworkAdapterPlugin };
+export { createDepsConfigPlugin, createFrameworkAdapterPlugin };

package/dist/store-9UNcAe5D.d.mts

@@ -0,0 +1,11 @@
+//#region src/server/store.d.ts
+interface VikeState {
+  routes: typeof import('virtual:vike-lite/routes')['routes'] | [];
+  errorRoute: typeof import('virtual:vike-lite/routes')['errorRoute'] | null;
+  config: typeof import('virtual:vike-lite/routes')['config'] | null;
+  manifest: typeof import('virtual:vike-lite/client-manifest')['default'] | null;
+}
+declare const store: VikeState;
+declare function setVikeState(newState: Partial<VikeState>): void;
+//#endregion
+export { setVikeState as n, store as r, VikeState as t };

package/dist/vite.mjs

@@ -19,7 +19,8 @@ function generateRoutes(viteRoot, pagesDir) {
 	const routes = [];
 	let errorRoute;
 	function walk(dir, routePath, parentLayout, parentHead) {
-		const files = fs.readdirSync(dir);
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		const files = entries.map((entry) => entry.name);
 		const importPath = path.relative(viteRoot, dir).replaceAll("\\", "/");
 		const layoutFile = findFile(files, "+Layout", pageExtensions);
 		const currentLayout = layoutFile ? `${importPath}/${layoutFile}` : parentLayout;
@@ -41,9 +42,10 @@ function generateRoutes(viteRoot, pagesDir) {
 			if (currentHead) route.head = currentHead;
 			routes.push(route);
 		}
-		for (const file of files) {
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const file = entry.name;
 			const fullPath = path.join(dir, file);
-			if (!fs.statSync(fullPath).isDirectory()) continue;
 			if (file === "_error") {
 				const errorPageFile = findFile(fs.readdirSync(fullPath), "+Page", pageExtensions);
 				if (errorPageFile) errorRoute = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike-lite",
-  "version": "1.15.13",
+  "version": "1.15.15",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -83,7 +83,8 @@
   "devDependencies": {
     "@types/node": "^26.1.1",
     "tsdown": "^0.22.9",
-    "vite": "^8.1.5"
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "vite": ">=8"