vike-lite-vue 0.1.0

package/README.md

@@ -0,0 +1,148 @@
+# vike-lite-vue
+
+The official Vue integration for `vike-lite`. It provides seamless Server-Side Rendering (SSR), Static Site Generation (SSG), and client hydration out of the box, with a focus on minimalism and performance.
+
+### ⚙️ Install
+You need to install both `vike-lite-vue` and the official Vite plugin for Vue (`@vitejs/plugin-vue`).
+
+```sh
+# npm
+npm install -D vike-lite-vue @vitejs/plugin-vue
+npm install vue
+
+# pnpm
+pnpm add -D vike-lite-vue @vitejs/plugin-vue
+pnpm add vue
+
+# yarn
+yarn add -D vike-lite-vue @vitejs/plugin-vue
+yarn add vue
+```
+
+### ⚙️ Vite Plugin
+Add the plugin to your `vite.config`.
+
+```ts
+// vite.config.ts
+import type { UserConfig } from 'vite'
+import vikeLite from 'vike-lite/vite'
+import vikeLiteVue from 'vike-lite-vue/vite'
+
+export default {
+  plugins: [
+    vikeLite(),
+    vikeLiteVue({
+    // Default is `true` that enables Vue Hydration
+    // Set to `false` for Client Takeover (SPA mode)
+    hydration: true,
+    // Advanced: pass options directly to the underlying @vitejs/plugin-vue
+    vue: {
+      template: {
+        compilerOptions: {
+          // e.g. custom compiler options
+        }
+      }
+    }
+})
+  ]
+} satisfies UserConfig
+```
+
+| Option | Type | Default | Description
+| - | - | - | -
+| `hydration` | `boolean` | `true` | When `true`, the server renders the page to HTML and the client hydrates it. When `false`, the client discards the server-rendered HTML on load and mounts a fresh tree — useful for highly interactive pages where paying the hydration-mismatch tax isn't worth it.
+| `solid` | `Options` (from `vite-plugin-solid`) | `{}` | Passed through to the underlying `vite-plugin-solid` instance. Use this for custom Babel plugins or any other low-level Solid compiler setting.
+
+### 🪝 Hooks
+
+#### `useData`
+Access the data fetched by your `+data` functions directly inside your Vue components.
+
+```vue
+<!-- /pages/+Page.vue -->
+<script setup lang="ts">
+import { useData } from 'vike-lite-vue'
+
+type MyData = { title: string }
+
+const [data, setData] = useData<MyData>()
+</script>
+
+<template>
+  <div>
+    <h1>{{ data.title }}</h1>
+    <button @click="setData(prev => ({ ...prev, title: 'Updated Title!' }))">
+      Update Data
+    </button>
+  </div>
+</template>
+```
+
+> 💡 **Note:** `data` is a `ComputedRef` — access it with `data.value` in `<script setup>`, but **without** `.value` directly in `<template>` (Vue automatically unwraps refs there). Like `vike-lite-solid` and `vike-lite-react`, `useData` returns a `[data, setData]` tuple so you can mutate the route data locally without an extra state manager.
+
+#### `usePageContext`
+Access the current page context, including URL parameters, original pathname, and route information.
+
+```vue
+<!-- /pages/+Page.vue -->
+<script setup lang="ts">
+import { usePageContext } from 'vike-lite-vue'
+
+const pageContext = usePageContext()
+</script>
+
+<template>
+  <p>Current Path: <strong>{{ pageContext.urlPathname }}</strong></p>
+</template>
+```
+
+> 💡 **Note:** `pageContext` here is a Vue `reactive()` object, not a ref — access its properties directly (`pageContext.urlPathname`), both in `<script setup>` and in `<template>`.
+
+#### `useHydrated`
+Detect whether the application has successfully hydrated on the client. Essential for wrapping client-only libraries (like chart tools or window-dependent logic) to avoid SSR hydration mismatches.
+
+```vue
+<!-- /pages/+Page.vue -->
+<script setup lang="ts">
+import { useHydrated } from 'vike-lite-vue'
+import ClientOnlyChart from './Chart.vue'
+
+const hydrated = useHydrated()
+</script>
+
+<template>
+  <div>
+    <h1>Statistics</h1>
+    <ClientOnlyChart v-if="hydrated" />
+    <p v-else>Loading chart…</p>
+  </div>
+</template>
+```
+
+#### `useUrl`
+```vue
+<!-- /pages/+Page.vue -->
+<script setup lang="ts">
+import { useUrl } from 'vike-lite-vue'
+
+const url = useUrl()
+</script>
+
+<template>
+  <p>Current Query Parameter "myQueryParam": <strong>{{ url.searchParams.get('myQueryParam') }}</strong></p>
+</template>
+```
+
+> 💡 **Note:** Like `vike-lite-solid` and `vike-lite-react`, `vike-lite-vue` provides a dedicated `useUrl` composable — a granular alternative to parsing `pageContext.urlOriginal` manually.
+
+### Differences: `vike-vue` vs `vike-lite-vue`
+
+| **Feature** | `vike-vue` | `vike-lite-vue` | **Why it matters**
+| - | - | - | -
+| **Reactivity Architecture** | _Single Source of Truth_ | _Separation of Concerns_ | `vike-lite-vue` keeps page data (`pageContext`) and the active UI (`view`: Page/Layout/Head) as two separate reactive atoms, so a data update doesn't force Vue to re-resolve which components are mounted, and vice versa.
+| **Accessibility (A11y)** | _Not_ handled by default | _Automatic_ handled | After a client-side navigation, `vike-lite-vue` moves the focus to `#root`. This significantly improves UX for keyboard navigation and screen readers.
+| `useData()` **Composable** | `getter` only | `[getter, setter]` | `vike-lite-vue` allows you to mutate the route data locally without needing other state managers.
+
+---
+
+This project is licensed under the [MIT License](../../LICENSE).

package/dist/__internal/client/onRenderClient.d.mts

@@ -0,0 +1,8 @@
+import { VikeState } from "vike-lite/__internal/server";
+//#region src/__internal/client/onRenderClient.d.ts
+declare function onRenderClient(clientOptions: {
+  routes: VikeState['routes'];
+  errorRoute: VikeState['errorRoute'];
+}): Promise<void>;
+//#endregion
+export { onRenderClient as default };

package/dist/__internal/client/onRenderClient.mjs

@@ -0,0 +1,283 @@
+import { t as pageContextInjectionKey } from "../../globalContext-Dk48ds1e.mjs";
+import { computed, createSSRApp, defineComponent, h, onMounted, onUnmounted, reactive, ref, watch } from "vue";
+import { matchRoute } from "vike-lite/__internal/shared";
+import { hydration } from "virtual:vike-lite/config";
+//#region src/__internal/shared/stripBase.ts
+function stripBase(pathname) {
+	const { BASE_URL } = import.meta.env;
+	if (BASE_URL === "/" || !pathname.startsWith(BASE_URL)) return pathname;
+	const stripped = pathname.slice(BASE_URL.length);
+	return stripped.startsWith("/") ? stripped : "/" + stripped;
+}
+//#endregion
+//#region src/__internal/client/onRenderClient.ts
+const RouterApp = defineComponent((props) => {
+	const pageContext = reactive({ ...props.initialContext });
+	const view = ref(props.initialView);
+	const currentUrl = ref(props.initialUrl);
+	const currentPathname = ref(props.initialContext.urlPathname);
+	const reloadTick = ref(0);
+	const shouldScrollToTop = { value: false };
+	const pendingContextOverride = { value: null };
+	const reloadResolvers = [];
+	let isFirstRun = true;
+	let abortController = null;
+	const matchedRoute = computed(() => matchRoute(currentPathname.value, props.routes));
+	function setPageContext(next) {
+		for (const key of Object.keys(pageContext)) delete pageContext[key];
+		Object.assign(pageContext, next);
+	}
+	async function loadRoute() {
+		abortController?.abort();
+		const controller = new AbortController();
+		abortController = controller;
+		const signal = controller.signal;
+		const pathname = currentPathname.value;
+		const urlFull = currentUrl.value;
+		const isReload = reloadTick.value > 0;
+		const matched = matchedRoute.value;
+		const contextOverride = pendingContextOverride.value;
+		pendingContextOverride.value = null;
+		function finalizeNavigation() {
+			if (shouldScrollToTop.value) {
+				window.scrollTo(0, 0);
+				shouldScrollToTop.value = false;
+			} else if (globalThis.location.hash) requestAnimationFrame(() => {
+				try {
+					document.querySelector(decodeURIComponent(globalThis.location.hash))?.scrollIntoView();
+				} catch {}
+			});
+		}
+		const renderErrorPage = async (is404, message) => {
+			if (!props.errorRoute) return;
+			const [ErrorPageMod, ErrorLayoutMod, ErrorHeadMod] = await Promise.all([
+				props.errorRoute.Page(),
+				props.errorRoute.Layout?.() ?? null,
+				props.errorRoute.Head?.() ?? null
+			]);
+			if (signal.aborted) return;
+			setPageContext({
+				urlOriginal: urlFull,
+				urlPathname: pathname,
+				routeParams: {},
+				is404,
+				is500: !is404,
+				errorMessage: message
+			});
+			view.value = {
+				Page: ErrorPageMod.Page ?? ErrorPageMod.default,
+				Layout: ErrorLayoutMod?.Layout ?? ErrorLayoutMod?.default ?? null,
+				Head: ErrorHeadMod?.Head ?? ErrorHeadMod?.default ?? null
+			};
+			document.title = is404 ? "Not Found" : "Server Error";
+			finalizeNavigation();
+		};
+		if (!matched) return renderErrorPage(true);
+		const { route, routeParams } = matched;
+		try {
+			const urlObj = new URL(urlFull);
+			const jsonTarget = pathname === "/" ? "/index" : pathname;
+			const { BASE_URL } = import.meta.env;
+			const jsonUrl = `${BASE_URL.endsWith("/") ? BASE_URL.slice(0, -1) : BASE_URL}${jsonTarget}.pageContext.json${urlObj.search}`;
+			let ctx = null;
+			if (route.data || route.title) {
+				const res = await fetch(jsonUrl, {
+					signal,
+					cache: isReload ? "no-cache" : "default"
+				});
+				const contentType = res.headers.get("content-type") ?? "";
+				if (!contentType.includes("application/json")) throw new Error(`Expected JSON but got "${contentType}" for ${jsonUrl}. Check your proxy/CDN configuration.`);
+				ctx = await res.json();
+			}
+			if (signal.aborted) return;
+			if (ctx?._redirect) {
+				const urlObjRedirect = new URL(ctx._redirect, globalThis.location.origin);
+				if (urlObjRedirect.origin !== globalThis.location.origin) {
+					globalThis.location.assign(ctx._redirect);
+					return;
+				}
+				globalThis.history.pushState({ triggeredBy: "vike-lite" }, "", ctx._redirect);
+				shouldScrollToTop.value = true;
+				currentUrl.value = urlObjRedirect.href;
+				currentPathname.value = stripBase(urlObjRedirect.pathname);
+				return;
+			}
+			if (ctx && (ctx.is404 || ctx.is500 || ctx.isError)) return renderErrorPage(ctx.is404, ctx.reason || "Server Error");
+			const [PageMod, LayoutMod, HeadMod] = await Promise.all([
+				route.Page(),
+				route.Layout?.() ?? null,
+				route.Head?.() ?? null
+			]);
+			if (signal.aborted) return;
+			setPageContext({
+				routeParams,
+				urlOriginal: urlObj.href,
+				urlPathname: pathname,
+				search: urlObj.search,
+				...ctx?.data && { data: ctx.data },
+				...ctx?.title && { title: ctx.title },
+				...contextOverride
+			});
+			view.value = {
+				Page: PageMod.Page ?? PageMod.default,
+				Layout: LayoutMod?.Layout ?? LayoutMod?.default ?? null,
+				Head: HeadMod?.Head ?? HeadMod?.default ?? null
+			};
+			if (ctx?.title) document.title = ctx.title;
+			requestAnimationFrame(() => {
+				if (globalThis.location.hash) return;
+				document.querySelector("#root")?.focus({ preventScroll: true });
+			});
+			finalizeNavigation();
+		} catch (error) {
+			if (error.name === "AbortError") return;
+			const message = error.message || "";
+			if (/dynamically imported module|importing a module script failed/i.test(message)) {
+				const GUARD_KEY = "vike-lite:reload-guard";
+				const last = Number(sessionStorage.getItem(GUARD_KEY) ?? 0);
+				if (Date.now() - last > 1e4) {
+					sessionStorage.setItem(GUARD_KEY, String(Date.now()));
+					console.warn("App update detected, forcing reload…");
+					globalThis.location.assign(urlFull);
+					return;
+				}
+			}
+			console.error("Router Error:", error);
+			renderErrorPage(false, message);
+		} finally {
+			if (!signal.aborted) {
+				for (const resolve of reloadResolvers) resolve();
+				reloadResolvers.length = 0;
+			}
+		}
+	}
+	onMounted(() => {
+		const handleLinkClick = (e) => {
+			const target = e.target.closest("a");
+			if (!target?.href || target.target === "_blank" || e.ctrlKey || e.metaKey || e.altKey || e.shiftKey) return;
+			const url = new URL(target.href);
+			if (url.origin !== globalThis.location.origin) return;
+			if (url.pathname === globalThis.location.pathname && url.search === globalThis.location.search) return;
+			e.preventDefault();
+			globalThis.history.pushState({ triggeredBy: "vike-lite" }, "", url.href);
+			if (!url.hash) shouldScrollToTop.value = true;
+			currentUrl.value = url.href;
+			currentPathname.value = stripBase(url.pathname);
+		};
+		const prefetchedModules = /* @__PURE__ */ new Set();
+		function prefetchRoute(route) {
+			const modules = [
+				[route.page, route.Page],
+				[route.layout, route.Layout],
+				[route.head, route.Head]
+			];
+			for (const [key, loader] of modules) {
+				if (!key || !loader || prefetchedModules.has(key)) continue;
+				prefetchedModules.add(key);
+				loader().catch(() => {
+					prefetchedModules.delete(key);
+				});
+			}
+		}
+		const handleLinkPrefetch = (e) => {
+			const target = e.target.closest("a");
+			if (!target?.href || target.target && target.target !== "_self" || target.hasAttribute("download")) return;
+			const url = new URL(target.href);
+			if (url.origin !== globalThis.location.origin) return;
+			if (url.pathname === globalThis.location.pathname && url.search === globalThis.location.search) return;
+			const matched = matchRoute(stripBase(url.pathname), props.routes);
+			if (matched) prefetchRoute(matched.route);
+		};
+		const handlePopState = () => {
+			currentUrl.value = globalThis.location.href;
+			currentPathname.value = stripBase(globalThis.location.pathname);
+		};
+		const handleProgrammaticNavigate = (e) => {
+			const detail = e.detail || {};
+			if (!detail.keepScrollPosition) shouldScrollToTop.value = true;
+			if (detail.pageContext) pendingContextOverride.value = detail.pageContext;
+			currentUrl.value = globalThis.location.href;
+			currentPathname.value = stripBase(globalThis.location.pathname);
+		};
+		const handleProgrammaticReload = (e) => {
+			const resolve = e.detail?.resolve;
+			if (resolve) reloadResolvers.push(resolve);
+			reloadTick.value++;
+		};
+		document.addEventListener("click", handleLinkClick);
+		document.addEventListener("pointerenter", handleLinkPrefetch, { capture: true });
+		document.addEventListener("focusin", handleLinkPrefetch);
+		globalThis.addEventListener("popstate", handlePopState);
+		globalThis.addEventListener("vike-navigate", handleProgrammaticNavigate);
+		globalThis.addEventListener("vike-reload", handleProgrammaticReload);
+		onUnmounted(() => {
+			document.removeEventListener("click", handleLinkClick);
+			document.removeEventListener("pointerenter", handleLinkPrefetch, { capture: true });
+			document.removeEventListener("focusin", handleLinkPrefetch);
+			globalThis.removeEventListener("popstate", handlePopState);
+			globalThis.removeEventListener("vike-navigate", handleProgrammaticNavigate);
+			globalThis.removeEventListener("vike-reload", handleProgrammaticReload);
+		});
+	});
+	watch([
+		currentPathname,
+		currentUrl,
+		reloadTick
+	], () => {
+		const pathname = currentPathname.value;
+		if (isFirstRun && reloadTick.value === 0 && globalThis.__PAGE_CONTEXT__?.urlPathname === pathname) {
+			isFirstRun = false;
+			globalThis.__PAGE_CONTEXT__.urlPathname = void 0;
+			return;
+		}
+		isFirstRun = false;
+		loadRoute();
+	});
+	return () => {
+		const { Page, Layout } = view.value;
+		if (!Page) return null;
+		return h("div", [Layout ? h(Layout, null, { default: () => h(Page) }) : h(Page)]);
+	};
+}, { props: [
+	"routes",
+	"errorRoute",
+	"initialView",
+	"initialContext",
+	"initialUrl"
+] });
+async function onRenderClient(clientOptions) {
+	const container = document.querySelector("#root");
+	const initialContext = globalThis.__PAGE_CONTEXT__ ?? {};
+	const isHydration = hydration && !!globalThis.__PAGE_CONTEXT__;
+	let initialView = {
+		Page: null,
+		Layout: null,
+		Head: null
+	};
+	if (isHydration) {
+		const matched = matchRoute(initialContext.urlPathname ?? globalThis.location.pathname, clientOptions.routes);
+		if (matched) {
+			const [PageMod, LayoutMod, HeadMod] = await Promise.all([
+				matched.route.Page(),
+				matched.route.Layout?.() ?? null,
+				matched.route.Head?.() ?? null
+			]);
+			initialView = {
+				Page: PageMod.Page ?? PageMod.default,
+				Layout: LayoutMod?.Layout ?? LayoutMod?.default ?? null,
+				Head: HeadMod?.Head ?? HeadMod?.default ?? null
+			};
+		}
+	}
+	const app = createSSRApp(RouterApp, {
+		...clientOptions,
+		initialView,
+		initialContext,
+		initialUrl: globalThis.location.href
+	});
+	app.provide(pageContextInjectionKey, { pageContext: reactive(initialContext) });
+	if (!isHydration) container.replaceChildren();
+	app.mount(container);
+}
+//#endregion
+export { onRenderClient as default };

package/dist/__internal/server/onRenderHtml.d.mts

@@ -0,0 +1,11 @@
+import { Component } from "vue";
+import { RenderContext } from "vike-lite/__internal/shared";
+//#region src/__internal/server/onRenderHtml.d.ts
+interface VueRenderContext extends RenderContext {
+  Page: Component;
+  Head?: Component;
+  Layout?: Component;
+}
+declare function onRenderHtml({ pageContext, Page, Head, Layout, pageTitleTag, serializedContext, assets }: VueRenderContext): Promise<string>;
+//#endregion
+export { VueRenderContext, onRenderHtml };

package/dist/__internal/server/onRenderHtml.mjs

@@ -0,0 +1,34 @@
+import { t as pageContextInjectionKey } from "../../globalContext-Dk48ds1e.mjs";
+import { createSSRApp, h } from "vue";
+import { renderToString } from "vue/server-renderer";
+//#region src/__internal/server/onRenderHtml.ts
+async function onRenderHtml({ pageContext, Page, Head, Layout, pageTitleTag, serializedContext, assets }) {
+	const { cssLinks, jsPreloads, entryClient } = assets;
+	let headHtml = "";
+	if (Head) {
+		const headApp = createSSRApp({ render: () => h(Head) });
+		headApp.provide(pageContextInjectionKey, { pageContext });
+		headHtml = await renderToString(headApp);
+	}
+	const app = createSSRApp({ render: () => Layout ? h(Layout, null, { default: () => h(Page) }) : h(Page) });
+	app.provide(pageContextInjectionKey, { pageContext });
+	const appHtml = await renderToString(app);
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+${pageTitleTag}
+${cssLinks}
+${jsPreloads}
+${headHtml}
+<script>window.__PAGE_CONTEXT__=${serializedContext}<\/script>
+</head>
+<body>
+<div id="root">${appHtml}</div>
+<script type="module" src="${entryClient}"><\/script>
+</body>
+</html>`;
+}
+//#endregion
+export { onRenderHtml };

package/dist/globalContext-Dk48ds1e.mjs

@@ -0,0 +1,7 @@
+//#region src/hooks/globalContext.ts
+const KEY = "_vike_lite_vue_context";
+const g = globalThis;
+if (!Object.hasOwn(g, KEY)) g[KEY] = Symbol("vike-lite-vue:pageContext");
+const pageContextInjectionKey = g[KEY];
+//#endregion
+export { pageContextInjectionKey as t };

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+import { ComputedRef, Ref } from "vue";
+import { PageContext } from "vike-lite";
+//#region src/hooks/useData.d.ts
+declare function useData<Data = unknown>(): [ComputedRef<Data>, (updater: Data | ((prev: Data) => Data)) => void];
+//#endregion
+//#region src/hooks/useHydrated.d.ts
+declare function useHydrated(): Ref<boolean>;
+//#endregion
+//#region src/hooks/usePageContext.d.ts
+declare function usePageContext(): PageContext;
+//#endregion
+//#region src/hooks/useUrl.d.ts
+declare function useUrl(): ComputedRef<URL>;
+//#endregion
+export { useData, useHydrated, usePageContext, useUrl };

package/dist/index.mjs

@@ -0,0 +1,37 @@
+import { t as pageContextInjectionKey } from "./globalContext-Dk48ds1e.mjs";
+import { computed, inject, onMounted, ref } from "vue";
+//#region src/hooks/useData.ts
+function useData() {
+	const ctx = inject(pageContextInjectionKey);
+	if (!ctx) throw new Error("useData() must be called inside a page rendered by vike-lite-vue");
+	const data = computed(() => ctx.pageContext.data);
+	const setData = (updater) => {
+		const next = typeof updater === "function" ? updater(ctx.pageContext.data) : updater;
+		ctx.pageContext.data = next;
+	};
+	return [data, setData];
+}
+//#endregion
+//#region src/hooks/useHydrated.ts
+function useHydrated() {
+	const hydrated = ref(false);
+	onMounted(() => {
+		hydrated.value = true;
+	});
+	return hydrated;
+}
+//#endregion
+//#region src/hooks/usePageContext.ts
+function usePageContext() {
+	const ctx = inject(pageContextInjectionKey);
+	if (!ctx) throw new Error("usePageContext() must be called inside a page rendered by vike-lite-vue");
+	return ctx.pageContext;
+}
+//#endregion
+//#region src/hooks/useUrl.ts
+function useUrl() {
+	const pageContext = usePageContext();
+	return computed(() => new URL(pageContext.urlOriginal));
+}
+//#endregion
+export { useData, useHydrated, usePageContext, useUrl };

package/dist/vite.d.mts

@@ -0,0 +1,17 @@
+import { Options } from "@vitejs/plugin-vue";
+import { PluginOption } from "vite";
+//#region src/vite.d.ts
+declare function vikeLiteVue({ hydration, vue: vueUserOptions }?: {
+  /**
+   * true: enable Vue Hydration (better UX)
+   * false: destroy the SSR DOM and recreate the app (Client Takeover, no hydration mismatch)
+   * @default true
+   */
+  hydration?: boolean;
+  /**
+   * Advanced options passed directly to @vitejs/plugin-vue
+   */
+  vue?: Partial<Options>;
+}): PluginOption[];
+//#endregion
+export { vikeLiteVue as default };

package/dist/vite.mjs

@@ -0,0 +1,36 @@
+import vuePlugin from "@vitejs/plugin-vue";
+import { mergeConfig } from "vite";
+//#region src/vite.ts
+function vikeLiteVue({ hydration = true, vue: vueUserOptions = {} } = {}) {
+	const virtualConfigId = "virtual:vike-lite/config";
+	const virtualClientId = "virtual:vike-lite/client";
+	const virtualServerId = "virtual:vike-lite/server";
+	const resolvedVirtualConfigId = "\0virtual:vike-lite/config";
+	const resolvedVirtualClientId = "\0virtual:vike-lite/client";
+	const resolvedVirtualServerId = "\0virtual:vike-lite/server";
+	return [vuePlugin(mergeConfig({ ssr: true }, vueUserOptions)), {
+		name: "vike-lite-vue",
+		enforce: "pre",
+		config() {
+			return {
+				optimizeDeps: {
+					include: ["vue"],
+					exclude: ["vike-lite-vue"]
+				},
+				ssr: { noExternal: ["vike-lite-vue"] }
+			};
+		},
+		resolveId(id) {
+			if (id === virtualConfigId) return resolvedVirtualConfigId;
+			if (id === virtualClientId) return resolvedVirtualClientId;
+			if (id === virtualServerId) return resolvedVirtualServerId;
+		},
+		load(id) {
+			if (id === resolvedVirtualConfigId) return `export const hydration=${hydration};`;
+			if (id === resolvedVirtualClientId) return `export const onRenderClient=()=>import('vike-lite-vue/__internal/client/onRenderClient');`;
+			if (id === resolvedVirtualServerId) return `export{onRenderHtml}from'vike-lite-vue/__internal/server/onRenderHtml';`;
+		}
+	}];
+}
+//#endregion
+export { vikeLiteVue as default };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "vike-lite-vue",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.mts",
+      "import": "./dist/vite.mjs"
+    },
+    "./__internal/client/onRenderClient": {
+      "types": "./dist/__internal/client/onRenderClient.d.mts",
+      "import": "./dist/__internal/client/onRenderClient.mjs"
+    },
+    "./__internal/server/onRenderHtml": {
+      "types": "./dist/__internal/server/onRenderHtml.d.mts",
+      "import": "./dist/__internal/server/onRenderHtml.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "tsc": "vue-tsc --noEmit",
+    "build": "tsdown"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "@vue/compiler-sfc": "^3.5.39",
+    "@vue/server-renderer": "^3.5.39",
+    "tsdown": "^0.22.5",
+    "typescript": "^6.0.3",
+    "unplugin-vue": "^7.2.0",
+    "vike-lite": "1.13.2",
+    "vite": "^8.1.4",
+    "vue": "^3.5.39",
+    "vue-tsc": "^3.3.7"
+  },
+  "peerDependencies": {
+    "@vitejs/plugin-vue": ">=6",
+    "vike-lite": "*",
+    "vite": ">=8",
+    "vue": "*"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  }
+}