@vizejs/musea-nuxt 0.269.0 → 0.271.0

package/dist/index.mjs

@@ -1,50 +1,34 @@
-import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { computed, defineComponent, h, reactive, ref } from "vue";
-//#region \0rolldown/runtime.js
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
+import { computed, defineComponent, h, reactive, ref, toValue } from "vue";
 //#region src/plugin.ts
 const VIRTUAL_IMPORTS_ID = "\0musea-nuxt:imports";
-const VIRTUAL_IMPORTS_MODULE = "#imports";
 const VIRTUAL_NUXT_COMPONENTS_ID = "\0musea-nuxt:components";
+const NUXT_IMPORT_IDS = new Set([
+	"#imports",
+	"#app",
+	"#build",
+	"nuxt/app"
+]);
+const NUXT_COMPONENT_IDS = new Set([
+	"#components",
+	"#build/components",
+	"nuxt/dist/app/components"
+]);
 function createNuxtMuseaPlugin(options = {}) {
 	const srcDir = path.dirname(fileURLToPath(import.meta.url));
 	return {
 		name: "vite-plugin-musea-nuxt",
 		enforce: "pre",
-		config() {
-			return { resolve: { alias: {
-				"#imports": VIRTUAL_IMPORTS_MODULE,
-				"#app": VIRTUAL_IMPORTS_MODULE,
-				"#build": VIRTUAL_IMPORTS_MODULE
-			} } };
-		},
 		resolveId(id) {
-			if (id === VIRTUAL_IMPORTS_MODULE || id === "#imports" || id === "#app" || id === "#build") return VIRTUAL_IMPORTS_ID;
-			if (id === "#components" || id === "nuxt/dist/app/components") return VIRTUAL_NUXT_COMPONENTS_ID;
+			if (NUXT_COMPONENT_IDS.has(id)) return VIRTUAL_NUXT_COMPONENTS_ID;
+			if (NUXT_IMPORT_IDS.has(id) || id.startsWith("#app/") || id.startsWith("#build/")) return VIRTUAL_IMPORTS_ID;
 			return null;
 		},
 		load(id) {
 			if (id === VIRTUAL_IMPORTS_ID) return generateImportsModule(srcDir, options);
 			if (id === VIRTUAL_NUXT_COMPONENTS_ID) return generateComponentsModule(srcDir);
 			return null;
-		},
-		transform(code, id) {
-			if (id.endsWith(".vue") || id.endsWith(".art.vue")) {
-				if (code.includes("<NuxtLink") || code.includes("<nuxt-link")) {
-					if (!code.includes("NuxtLink")) {
-						const importLine = `import { NuxtLink } from '${VIRTUAL_IMPORTS_MODULE}';\n`;
-						const lastImportIdx = code.lastIndexOf("import ");
-						if (lastImportIdx !== -1) {
-							const lineEnd = code.indexOf("\n", lastImportIdx);
-							code = code.slice(0, lineEnd + 1) + importLine + code.slice(lineEnd + 1);
-						}
-					}
-				}
-			}
-			return code;
 		}
 	};
 }
@@ -56,15 +40,10 @@ function generateImportsModule(srcDir, options) {
 export * from '${autoImportsPath}';
 
 // Configure mocks with provided options
-import { _setRouteConfig } from '${path.join(srcDir, "mocks", "composables.js").replace(/\\/g, "/")}';
-import { _setFetchMocks } from '${path.join(srcDir, "mocks", "data.js").replace(/\\/g, "/")}';
-import { _setRuntimeConfig, _setStateMocks } from '${path.join(srcDir, "mocks", "runtime.js").replace(/\\/g, "/")}';
+import { configureNuxtMuseaMocks } from '${path.join(srcDir, "context.js").replace(/\\/g, "/")}';
 
 const _config = ${configJson};
-_setRouteConfig(_config.route);
-_setFetchMocks(_config.fetchMocks ?? {});
-_setRuntimeConfig(_config.runtimeConfig);
-_setStateMocks(_config.stateMocks ?? {});
+configureNuxtMuseaMocks(_config);
 `;
 }
 function generateComponentsModule(srcDir) {
@@ -77,122 +56,184 @@ export {
   NuxtLayout,
   NuxtLoadingIndicator,
   NuxtErrorBoundary,
+  NuxtRouteAnnouncer,
+  NuxtWelcome,
+  NuxtIsland,
+  NuxtClientFallback,
+  NuxtImg,
+  NuxtPicture,
 } from '${path.join(srcDir, "mocks", "components.js").replace(/\\/g, "/")}';
 `;
 }
 //#endregion
-//#region src/mocks/composables.ts
-/**
-* Mock Nuxt routing composables.
-*/
-let _routeConfig = {};
-/**
-* Mock useRoute - returns a reactive route object.
-*/
-function useRoute() {
-	return reactive({
-		path: _routeConfig?.path ?? "/",
-		name: _routeConfig?.name ?? "index",
-		params: _routeConfig?.params ?? {},
-		query: _routeConfig?.query ?? {},
-		hash: _routeConfig?.hash ?? "",
-		fullPath: _routeConfig?.fullPath ?? _routeConfig?.path ?? "/",
-		meta: _routeConfig?.meta ?? {},
-		matched: [],
-		redirectedFrom: void 0
+//#region src/context.ts
+const DEFAULT_REQUEST_URL = "http://localhost:3000/";
+const routeState = reactive(createRoute({}));
+const runtimeConfigState = reactive({ public: {} });
+const appConfigState = reactive({});
+const requestState = reactive({
+	url: DEFAULT_REQUEST_URL,
+	headers: {}
+});
+const stateRefs = /* @__PURE__ */ new Map();
+const cookieRefs = /* @__PURE__ */ new Map();
+const callOnceKeys = /* @__PURE__ */ new Set();
+const fetchMocksState = {};
+const errorRef = ref(null);
+let idCounter = 0;
+function configureNuxtMuseaMocks(options = {}) {
+	setRouteConfig(options.route ?? {});
+	setRuntimeConfig(options.runtimeConfig ?? {});
+	setAppConfig(options.appConfig ?? {});
+	setFetchMocks(options.fetchMocks ?? {});
+	setStateMocks(options.stateMocks ?? {});
+	setCookieMocks(options.cookieMocks ?? {});
+	setRequestConfig(options.request ?? {});
+}
+function resetNuxtMuseaMocks() {
+	setRouteConfig({});
+	setRuntimeConfig({});
+	setAppConfig({});
+	setFetchMocks({});
+	setRequestConfig({});
+	stateRefs.clear();
+	cookieRefs.clear();
+	callOnceKeys.clear();
+	errorRef.value = null;
+	idCounter = 0;
+}
+function getRouteState() {
+	return routeState;
+}
+function setRouteConfig(config) {
+	Object.assign(routeState, createRoute(config));
+}
+function resolveNavigationTarget(target) {
+	if (typeof target === "string") return createRoute({ path: target });
+	return createRoute({
+		path: target.path,
+		name: target.name ?? null,
+		params: target.params,
+		query: target.query,
+		hash: target.hash,
+		meta: typeof target.meta === "object" && target.meta != null ? target.meta : void 0
 	});
 }
-/**
-* Mock useRouter - returns a router-like object with no-op navigation.
-*/
-function useRouter() {
-	return {
-		push: async (_to) => {},
-		replace: async (_to) => {},
-		back: () => {},
-		forward: () => {},
-		go: (_delta) => {},
-		resolve: (to) => ({
-			href: typeof to === "string" ? to : "/",
-			route: useRoute()
-		}),
-		currentRoute: computed(() => useRoute()),
-		addRoute: () => () => {},
-		removeRoute: () => {},
-		hasRoute: () => false,
-		getRoutes: () => [],
-		beforeEach: () => () => {},
-		afterEach: () => () => {},
-		onError: () => () => {},
-		isReady: () => Promise.resolve(),
-		options: {}
-	};
+function getRuntimeConfigState() {
+	return runtimeConfigState;
 }
-//#endregion
-//#region src/mocks/data.ts
-/**
-* Mock Nuxt data-fetching composables.
-*/
-let _fetchMocks = {};
-function findMockData(key) {
-	if (key in _fetchMocks) return _fetchMocks[key];
-	for (const [pattern, data] of Object.entries(_fetchMocks)) if (key.includes(pattern)) return data;
+function setRuntimeConfig(config) {
+	replaceRecord(runtimeConfigState, {
+		public: {},
+		...config
+	});
 }
-/**
-* Mock useFetch - returns reactive data based on mock config.
-*/
-function useFetch(url, _opts) {
-	const data = ref(findMockData(typeof url === "function" ? url() : url) ?? null);
-	const pending = ref(false);
-	const error = ref(null);
-	const status = ref("success");
-	const refresh = async () => {};
-	const execute = async () => {};
-	return {
-		data,
-		pending,
-		error,
-		refresh,
-		execute,
-		status
-	};
+function getAppConfigState() {
+	return appConfigState;
 }
-/**
-* Mock useAsyncData - similar to useFetch but with key-based lookup.
-*/
-function useAsyncData(key, _handler, _opts) {
-	const data = ref(findMockData(key) ?? null);
-	const pending = ref(false);
-	const error = ref(null);
-	const status = ref("success");
-	const refresh = async () => {};
-	const execute = async () => {};
+function setAppConfig(config) {
+	replaceRecord(appConfigState, config);
+}
+function updateAppConfigState(config) {
+	Object.assign(appConfigState, config);
+}
+function getFetchMocks() {
+	return fetchMocksState;
+}
+function setFetchMocks(mocks) {
+	replaceRecord(fetchMocksState, mocks);
+}
+function getStateRef(key, init) {
+	const existing = stateRefs.get(key);
+	if (existing) return existing;
+	const state = ref(init ? init() : void 0);
+	stateRefs.set(key, state);
+	return state;
+}
+function setStateMocks(mocks) {
+	stateRefs.clear();
+	for (const [key, value] of Object.entries(mocks)) stateRefs.set(key, ref(value));
+}
+function clearStateRefs(keys) {
+	if (keys == null) {
+		stateRefs.clear();
+		return;
+	}
+	for (const key of Array.isArray(keys) ? keys : [keys]) stateRefs.delete(key);
+}
+function getCookieRef(name, init) {
+	const existing = cookieRefs.get(name);
+	if (existing) return existing;
+	const cookie = ref(init ? init() : void 0);
+	cookieRefs.set(name, cookie);
+	return cookie;
+}
+function setCookieMocks(mocks) {
+	cookieRefs.clear();
+	for (const [key, value] of Object.entries(mocks)) cookieRefs.set(key, ref(value));
+}
+function getRequestState() {
+	return requestState;
+}
+function setRequestConfig(request) {
+	requestState.url = request.url ?? DEFAULT_REQUEST_URL;
+	requestState.headers = { ...request.headers };
+}
+function getErrorRef() {
+	return errorRef;
+}
+function setError(error) {
+	errorRef.value = error;
+}
+function nextNuxtId() {
+	idCounter += 1;
+	return `musea-nuxt-${idCounter}`;
+}
+async function runCallOnce(key, fn) {
+	if (callOnceKeys.has(key)) return;
+	callOnceKeys.add(key);
+	return await fn();
+}
+function createRoute(config) {
+	const path = config.path ?? "/";
+	const query = { ...config.query };
+	const hash = normalizeHash(config.hash ?? "");
 	return {
-		data,
-		pending,
-		error,
-		refresh,
-		execute,
-		status
+		path,
+		name: config.name ?? inferRouteName(path),
+		params: { ...config.params },
+		query,
+		hash,
+		fullPath: config.fullPath ?? buildFullPath(path, query, hash),
+		meta: { ...config.meta },
+		matched: [...config.matched ?? []],
+		redirectedFrom: config.redirectedFrom
 	};
 }
-/**
-* Mock useLazyFetch - lazy variant of useFetch.
-*/
-function useLazyFetch(url, opts) {
-	return useFetch(url, {
-		...opts,
-		lazy: true
-	});
+function inferRouteName(path) {
+	const normalized = path.replace(/^\/+|\/+$/g, "");
+	return normalized.length === 0 ? "index" : normalized.replace(/[^A-Za-z0-9_]+/g, "-");
 }
-/**
-* Mock useLazyAsyncData - lazy variant of useAsyncData.
-*/
-function useLazyAsyncData(key, handler, opts) {
-	return useAsyncData(key, handler, {
-		...opts,
-		lazy: true
-	});
+function buildFullPath(path, query, hash) {
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value == null) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) searchParams.append(key, item);
+			continue;
+		}
+		searchParams.set(key, value);
+	}
+	const search = searchParams.toString();
+	return `${path}${search ? `?${search}` : ""}${hash}`;
+}
+function normalizeHash(hash) {
+	if (!hash) return "";
+	return hash.startsWith("#") ? hash : `#${hash}`;
+}
+function replaceRecord(target, value) {
+	for (const key of Object.keys(target)) delete target[key];
+	Object.assign(target, value);
 }
 //#endregion
 //#region src/mocks/navigation.ts
@@ -200,78 +241,78 @@ function useLazyAsyncData(key, handler, opts) {
 * Mock Nuxt navigation utilities.
 */
 /**
-* Mock navigateTo - no-op in gallery context.
+* Mock navigateTo - updates the shared route state in gallery context.
 */
-function navigateTo(_to, _opts) {
+function navigateTo(to, _opts) {
+	setRouteConfig(resolveNavigationTarget(to));
 	return Promise.resolve();
 }
 /**
 * Mock abortNavigation - no-op in gallery context.
 */
 function abortNavigation(_err) {}
-//#endregion
-//#region src/mocks/head.ts
 /**
-* Mock Nuxt head management composables.
-* All are no-ops in the gallery context.
+* Mock defineNuxtRouteMiddleware - returns the middleware function as-is.
 */
+function defineNuxtRouteMiddleware(middleware) {
+	return middleware;
+}
 /**
-* Mock useHead - no-op.
-*/
-function useHead(_input) {}
-/**
-* Mock useSeoMeta - no-op.
-*/
-function useSeoMeta(_input) {}
-//#endregion
-//#region src/mocks/runtime.ts
-/**
-* Mock Nuxt runtime composables.
+* Mock definePageMeta - page metadata is handled by Nuxt at build time.
 */
-let _runtimeConfig = {};
-let _stateMocks = {};
+function definePageMeta(_meta) {}
 /**
-* Mock useNuxtApp - returns a minimal Nuxt app-like object.
+* Mock setPageLayout - no layout switching in isolated previews.
 */
-function useNuxtApp() {
-	return {
-		$config: reactive({
-			public: _runtimeConfig?.public ?? {},
-			..._runtimeConfig
-		}),
-		provide: (_name, _value) => {},
-		hook: (_name, _fn) => {},
-		callHook: async (_name, ..._args) => {},
-		vueApp: null,
-		payload: reactive({
-			data: {},
-			state: {}
-		}),
-		isHydrating: false,
-		runWithContext: (fn) => fn()
-	};
+function setPageLayout(_layout) {}
+function prefetchComponents(_to) {
+	return Promise.resolve();
+}
+function preloadComponents(_to) {
+	return Promise.resolve();
 }
+function preloadRouteComponents(_to) {
+	return Promise.resolve();
+}
+//#endregion
+//#region src/mocks/composables.ts
 /**
-* Mock useRuntimeConfig - returns the configured runtime config.
+* Mock Nuxt routing composables.
 */
-function useRuntimeConfig() {
-	return reactive({
-		public: _runtimeConfig?.public ?? {},
-		..._runtimeConfig
-	});
-}
 /**
-* Mock useState - returns a ref initialized from mock config or init function.
+* Mock useRoute - returns a reactive route object.
 */
-function useState(key, init) {
-	if (key in _stateMocks) return ref(_stateMocks[key]);
-	return ref(init ? init() : void 0);
+function useRoute() {
+	return getRouteState();
 }
 /**
-* Mock useCookie - returns a ref-like cookie mock.
+* Mock useRouter - returns a router-like object with no-op navigation.
 */
-function useCookie(_name, _opts) {
-	return ref(void 0);
+function useRouter() {
+	const navigate = async (to) => {
+		setRouteConfig(resolveNavigationTarget(to));
+	};
+	return {
+		push: navigate,
+		replace: navigate,
+		back: () => {},
+		forward: () => {},
+		go: (_delta) => {},
+		resolve: (to) => ({
+			href: resolveNavigationTarget(to).fullPath,
+			route: resolveNavigationTarget(to)
+		}),
+		currentRoute: computed(() => useRoute()),
+		addRoute: () => () => {},
+		removeRoute: () => {},
+		hasRoute: () => false,
+		getRoutes: () => [],
+		beforeEach: () => () => {},
+		afterEach: () => () => {},
+		onError: () => () => {},
+		isReady: () => Promise.resolve(),
+		options: {}
+	};
 }
 //#endregion
 //#region src/mocks/components.ts
@@ -323,27 +364,35 @@ const NuxtLink = defineComponent({
 		exactActiveClass: {
 			type: String,
 			default: "router-link-exact-active"
+		},
+		custom: {
+			type: Boolean,
+			default: false
 		}
 	},
 	setup(props, { slots }) {
 		return () => {
-			const to = props.href || props.to;
-			if (props.external || typeof to === "string" && to.startsWith("http")) return h("a", {
-				href: typeof to === "string" ? to : "/",
+			const target = props.href ?? props.to;
+			const href = typeof target === "string" ? target : routeTargetToHref(target);
+			const navigate = () => navigateTo(target, { replace: props.replace });
+			if (props.custom) return slots.default?.({
+				href,
+				navigate,
+				route: useRoute(),
+				isActive: false,
+				isExactActive: false
+			});
+			return h("a", {
+				"data-nuxt-link": "",
+				href,
 				target: props.target,
-				rel: props.rel ?? (props.target === "_blank" ? "noopener noreferrer" : void 0)
+				rel: props.rel ?? (props.target === "_blank" ? "noopener noreferrer" : void 0),
+				onClick: (event) => {
+					if (props.external || props.target === "_blank" || isExternalHref(href)) return;
+					event.preventDefault();
+					navigate();
+				}
 			}, slots.default?.());
-			try {
-				const { RouterLink } = __require("vue-router");
-				return h(RouterLink, {
-					to,
-					replace: props.replace,
-					activeClass: props.activeClass,
-					exactActiveClass: props.exactActiveClass
-				}, slots);
-			} catch {
-				return h("a", { href: typeof to === "string" ? to : "/" }, slots.default?.());
-			}
 		};
 	}
 });
@@ -373,12 +422,7 @@ const NuxtPage = defineComponent({
 	setup(props, { slots }) {
 		return () => {
 			if (slots.default) return slots.default();
-			try {
-				const { RouterView } = __require("vue-router");
-				return h(RouterView, { name: props.name });
-			} catch {
-				return h("div", { "data-nuxt-page": "" }, "NuxtPage placeholder");
-			}
+			return h("div", { "data-nuxt-page": props.name }, "NuxtPage placeholder");
 		};
 	}
 });
@@ -428,6 +472,380 @@ const NuxtErrorBoundary = defineComponent({
 		return () => slots.default?.() ?? null;
 	}
 });
+const NuxtRouteAnnouncer = defineComponent({
+	name: "NuxtRouteAnnouncer",
+	props: { politeness: {
+		type: String,
+		default: "polite"
+	} },
+	setup(props) {
+		return () => h("span", {
+			"aria-live": props.politeness,
+			"data-nuxt-route-announcer": "",
+			style: "position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0,0,0,0);"
+		});
+	}
+});
+const NuxtWelcome = defineComponent({
+	name: "NuxtWelcome",
+	setup() {
+		return () => h("div", { "data-nuxt-welcome": "" }, "NuxtWelcome placeholder");
+	}
+});
+const NuxtIsland = defineComponent({
+	name: "NuxtIsland",
+	setup(_props, { slots }) {
+		return () => slots.default?.() ?? null;
+	}
+});
+const NuxtClientFallback = defineComponent({
+	name: "NuxtClientFallback",
+	setup(_props, { slots }) {
+		return () => slots.default?.() ?? slots.fallback?.() ?? null;
+	}
+});
+const NuxtImg = defineComponent({
+	name: "NuxtImg",
+	props: {
+		src: {
+			type: String,
+			required: true
+		},
+		alt: {
+			type: String,
+			default: ""
+		},
+		width: {
+			type: [String, Number],
+			default: void 0
+		},
+		height: {
+			type: [String, Number],
+			default: void 0
+		}
+	},
+	setup(props, { attrs }) {
+		return () => h("img", {
+			...attrs,
+			src: props.src,
+			alt: props.alt,
+			width: props.width,
+			height: props.height
+		});
+	}
+});
+const NuxtPicture = defineComponent({
+	name: "NuxtPicture",
+	props: {
+		src: {
+			type: String,
+			required: true
+		},
+		alt: {
+			type: String,
+			default: ""
+		}
+	},
+	setup(props, { attrs }) {
+		return () => h("picture", {}, [h("img", {
+			...attrs,
+			src: props.src,
+			alt: props.alt
+		})]);
+	}
+});
+function routeTargetToHref(to) {
+	return resolveNavigationTarget(to).fullPath;
+}
+function isExternalHref(href) {
+	return /^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(href);
+}
+//#endregion
+//#region src/mocks/runtime.ts
+/**
+* Mock Nuxt runtime composables.
+*/
+/**
+* Mock useNuxtApp - returns a minimal Nuxt app-like object.
+*/
+function useNuxtApp() {
+	return {
+		$config: useRuntimeConfig(),
+		$router: useRouter(),
+		$route: useRoute(),
+		provide: (_name, _value) => {},
+		hook: (_name, _fn) => {},
+		callHook: async (_name, ..._args) => {},
+		vueApp: null,
+		payload: reactive({
+			data: {},
+			state: {}
+		}),
+		isHydrating: false,
+		runWithContext: (fn) => fn()
+	};
+}
+/**
+* Mock useRuntimeConfig - returns the configured runtime config.
+*/
+function useRuntimeConfig() {
+	return getRuntimeConfigState();
+}
+function useAppConfig() {
+	return getAppConfigState();
+}
+function updateAppConfig(config) {
+	updateAppConfigState(config);
+}
+/**
+* Mock useState - returns a ref initialized from mock config or init function.
+*/
+function useState(key, init) {
+	return getStateRef(key, init);
+}
+/**
+* Mock useRequestHeaders - returns empty headers in gallery context.
+*/
+function useRequestHeaders(_include) {
+	return { ...getRequestState().headers };
+}
+/**
+* Mock useRequestEvent - returns undefined in gallery context.
+*/
+function useRequestEvent() {}
+/**
+* Mock useRequestURL - returns current window location.
+*/
+function useRequestURL() {
+	if (typeof window !== "undefined") return new URL(window.location.href);
+	return new URL(getRequestState().url);
+}
+/**
+* Mock useCookie - returns a ref-like cookie mock.
+*/
+function useCookie(name, opts) {
+	return getCookieRef(name, opts?.default);
+}
+/**
+* Mock clearNuxtState - no-op.
+*/
+function clearNuxtState(keys) {
+	clearStateRefs(keys);
+}
+/**
+* Mock defineNuxtPlugin - returns the plugin function as-is.
+*/
+function defineNuxtPlugin(plugin) {
+	return plugin;
+}
+function defineNuxtComponent(component) {
+	return component;
+}
+function onNuxtReady(callback) {
+	if (typeof queueMicrotask === "function") {
+		queueMicrotask(callback);
+		return;
+	}
+	Promise.resolve().then(callback);
+}
+function callOnce(keyOrFn, fn) {
+	if (typeof keyOrFn === "function") return runCallOnce("__default__", keyOrFn);
+	return runCallOnce(keyOrFn, fn ?? (() => void 0));
+}
+function useId() {
+	return nextNuxtId();
+}
+function reloadNuxtApp(_options) {
+	return Promise.resolve();
+}
+//#endregion
+//#region src/app.ts
+const builtInComponents = {
+	NuxtLink,
+	NuxtPage,
+	ClientOnly,
+	NuxtLayout,
+	NuxtLoadingIndicator,
+	NuxtErrorBoundary,
+	NuxtRouteAnnouncer,
+	NuxtWelcome,
+	NuxtIsland,
+	NuxtClientFallback,
+	NuxtImg,
+	NuxtPicture
+};
+function installNuxtMuseaMocks(app, options = {}) {
+	configureNuxtMuseaMocks(options);
+	for (const [name, component] of Object.entries(builtInComponents)) app.component(name, component);
+	app.config.globalProperties.$config = useRuntimeConfig();
+	app.config.globalProperties.$route = useRoute();
+	app.config.globalProperties.$router = useRouter();
+	app.provide("nuxt-app", useNuxtApp());
+	return app;
+}
+function createNuxtMuseaPreviewSetup(options = {}) {
+	return (app) => {
+		installNuxtMuseaMocks(app, options);
+	};
+}
+//#endregion
+//#region src/mocks/data.ts
+/**
+* Mock Nuxt data-fetching composables.
+*/
+function findMockData(key) {
+	const fetchMocks = getFetchMocks();
+	if (key in fetchMocks) return fetchMocks[key];
+	for (const [pattern, data] of Object.entries(fetchMocks)) if (key.includes(pattern)) return data;
+}
+/**
+* Mock useFetch - returns reactive data based on mock config.
+*/
+function useFetch(url, opts) {
+	return createAsyncDataResult(stringifyDataKey(toValue(url)), void 0, opts);
+}
+/**
+* Mock useAsyncData - similar to useFetch but with key-based lookup.
+*/
+function useAsyncData(key, handler, opts) {
+	return createAsyncDataResult(key, handler, opts);
+}
+/**
+* Mock useLazyFetch - lazy variant of useFetch.
+*/
+function useLazyFetch(url, opts) {
+	return useFetch(url, {
+		...opts,
+		lazy: true
+	});
+}
+/**
+* Mock useLazyAsyncData - lazy variant of useAsyncData.
+*/
+function useLazyAsyncData(key, handler, opts) {
+	return useAsyncData(key, handler, {
+		...opts,
+		lazy: true
+	});
+}
+function refreshNuxtData(_keys) {
+	return Promise.resolve();
+}
+function clearNuxtData(_keys) {}
+function useNuxtData(key) {
+	return { data: ref(findMockData(key) ?? null) };
+}
+function useRequestFetch() {
+	return async (url) => {
+		return findMockData(stringifyDataKey(url));
+	};
+}
+function createAsyncDataResult(key, handler, opts = {}) {
+	const initial = resolveInitialData(key, opts);
+	const data = ref(initial);
+	const pending = ref(false);
+	const error = ref(null);
+	const status = ref(initial == null ? "idle" : "success");
+	const execute = async () => {
+		pending.value = true;
+		status.value = "pending";
+		error.value = null;
+		try {
+			const mockData = findMockData(key);
+			data.value = applyDataOptions(mockData !== void 0 ? mockData : handler ? await handler() : data.value, opts);
+			status.value = "success";
+		} catch (caught) {
+			error.value = caught instanceof Error ? caught : new Error(String(caught));
+			status.value = "error";
+		} finally {
+			pending.value = false;
+		}
+	};
+	if (opts.immediate !== false && opts.lazy !== true && initial == null && handler) execute();
+	return {
+		data,
+		pending,
+		error,
+		refresh: execute,
+		execute,
+		clear: () => {
+			data.value = null;
+			error.value = null;
+			pending.value = false;
+			status.value = "idle";
+		},
+		status
+	};
+}
+function resolveInitialData(key, opts) {
+	const mockData = findMockData(key);
+	if (mockData !== void 0) return applyDataOptions(mockData, opts);
+	return opts.default ? opts.default() : null;
+}
+function applyDataOptions(value, opts) {
+	const transformed = opts.transform ? opts.transform(value) : value;
+	if (!opts.pick || typeof transformed !== "object" || transformed == null) return transformed;
+	const picked = {};
+	for (const key of opts.pick) picked[key] = transformed[key];
+	return picked;
+}
+function stringifyDataKey(value) {
+	return typeof value === "string" ? value : value.toString();
+}
+//#endregion
+//#region src/mocks/head.ts
+function createHeadEntry() {
+	return {
+		dispose: () => {},
+		patch: (_input) => {},
+		pause: () => {},
+		resume: () => {}
+	};
+}
+/**
+* Mock useHead - no-op.
+*/
+function useHead(_input) {
+	return createHeadEntry();
+}
+/**
+* Mock useSeoMeta - no-op.
+*/
+function useSeoMeta(_input) {
+	return createHeadEntry();
+}
+/**
+* Mock useHeadSafe - no-op.
+*/
+function useHeadSafe(_input) {
+	return createHeadEntry();
+}
+/**
+* Mock useServerSeoMeta - no-op.
+*/
+function useServerSeoMeta(_input) {
+	return createHeadEntry();
+}
+//#endregion
+//#region src/mocks/error.ts
+function createError(input) {
+	const message = typeof input === "string" ? input : input.message ?? input.statusMessage ?? "Error";
+	const error = new Error(message);
+	if (typeof input === "object") Object.assign(error, input);
+	return error;
+}
+function showError(input) {
+	const error = createError(input);
+	setError(error);
+	return error;
+}
+function clearError(_options) {
+	setError(null);
+	return Promise.resolve();
+}
+function useError() {
+	return getErrorRef();
+}
 //#endregion
 //#region src/index.ts
 /**
@@ -437,4 +855,4 @@ function nuxtMusea(options = {}) {
 	return createNuxtMuseaPlugin(options);
 }
 //#endregion
-export { ClientOnly, NuxtErrorBoundary, NuxtLayout, NuxtLink, NuxtLoadingIndicator, NuxtPage, abortNavigation, navigateTo, nuxtMusea, useAsyncData, useCookie, useFetch, useHead, useLazyAsyncData, useLazyFetch, useNuxtApp, useRoute, useRouter, useRuntimeConfig, useSeoMeta, useState };
+export { ClientOnly, NuxtClientFallback, NuxtErrorBoundary, NuxtImg, NuxtIsland, NuxtLayout, NuxtLink, NuxtLoadingIndicator, NuxtPage, NuxtPicture, NuxtRouteAnnouncer, NuxtWelcome, abortNavigation, callOnce, clearError, clearNuxtData, clearNuxtState, configureNuxtMuseaMocks, createError, createNuxtMuseaPreviewSetup, defineNuxtComponent, defineNuxtPlugin, defineNuxtRouteMiddleware, definePageMeta, getAppConfigState, getRouteState, getRuntimeConfigState, installNuxtMuseaMocks, navigateTo, nuxtMusea, onNuxtReady, prefetchComponents, preloadComponents, preloadRouteComponents, refreshNuxtData, reloadNuxtApp, resetNuxtMuseaMocks, setPageLayout, showError, updateAppConfig, useAppConfig, useAsyncData, useCookie, useError, useFetch, useHead, useHeadSafe, useId, useLazyAsyncData, useLazyFetch, useNuxtApp, useNuxtData, useRequestEvent, useRequestFetch, useRequestHeaders, useRequestURL, useRoute, useRouter, useRuntimeConfig, useSeoMeta, useServerSeoMeta, useState };