@ubean/runtime 0.1.2 → 0.1.3

package/dist/app-dx92OPRP.js

@@ -0,0 +1,892 @@
+import { useHead as useUnheadHead, useSeoMeta } from "@unhead/vue";
+import { LOCALE_DATA_ID } from "@ubean/pages";
+import { KeepAlive, Transition, computed, createApp, createSSRApp, defineComponent, h, inject, markRaw, provide, reactive, ref, shallowRef, watchEffect } from "vue";
+import { RouterLink, RouterView, createMemoryHistory, createRouter, createWebHistory, useRoute, useRouter } from "vue-router";
+import { Head } from "@unhead/vue/components";
+import { addLocale, clearLocales, defineLocale, detectBrowserLocale, detectLocale, extractLocaleFromPath, getDefaultLocale, getI18nConfig, getLocale, getLocaleDir, getLocaleName, getRegisteredLocales, localizePath, mergeLocale, onLocaleChange, setI18nConfig, setLocale, switchLocalePath, t, useI18n } from "@ubean/i18n";
+//#region src/i18n.ts
+const _global$1 = globalThis;
+function hydrateLocale() {
+	if (typeof _global$1.document === "undefined") return {
+		locale: null,
+		dir: "ltr"
+	};
+	const el = _global$1.document.getElementById(LOCALE_DATA_ID);
+	if (!el) return {
+		locale: null,
+		dir: "ltr"
+	};
+	try {
+		const data = JSON.parse(el.textContent || "null");
+		if (data && typeof data.locale === "string") return {
+			locale: data.locale,
+			dir: data.dir === "rtl" ? "rtl" : "ltr",
+			messages: data.messages,
+			availableLocales: Array.isArray(data.availableLocales) ? data.availableLocales : void 0
+		};
+	} catch {
+		return {
+			locale: null,
+			dir: "ltr"
+		};
+	}
+	return {
+		locale: null,
+		dir: "ltr"
+	};
+}
+function syncHtmlLang(locale, dir) {
+	if (typeof _global$1.document === "undefined") return;
+	const html = _global$1.document.documentElement;
+	if (html) {
+		html.setAttribute("lang", locale);
+		html.setAttribute("dir", dir);
+	}
+}
+const { locale: hydratedLocale, dir: hydratedDir, messages: hydratedMessages, availableLocales: hydratedAvailable } = hydrateLocale();
+if (hydratedLocale) {
+	if (hydratedAvailable && hydratedAvailable.length > 0) {
+		const sorted = [...hydratedAvailable].sort((a, b) => (b.isDefault ? 1 : 0) - (a.isDefault ? 1 : 0));
+		for (const loc of sorted) {
+			const isCurrent = loc.code === hydratedLocale;
+			defineLocale({
+				code: loc.code,
+				messages: isCurrent && hydratedMessages ? hydratedMessages : {},
+				name: loc.name,
+				dir: loc.dir,
+				isDefault: loc.isDefault
+			});
+		}
+	} else if (hydratedMessages && typeof hydratedMessages === "object") defineLocale({
+		code: hydratedLocale,
+		messages: hydratedMessages,
+		dir: hydratedDir
+	});
+	setLocale(hydratedLocale);
+	syncHtmlLang(hydratedLocale, hydratedDir);
+}
+const localeRef = ref(getLocale());
+onLocaleChange((newLocale) => {
+	localeRef.value = newLocale;
+	syncHtmlLang(newLocale, getLocaleDir(newLocale));
+});
+function useI18n$1() {
+	const core = useI18n();
+	const localeDir = computed(() => getLocaleDir(localeRef.value));
+	const localeName = computed(() => getLocaleName(localeRef.value));
+	function translate(key, params) {
+		localeRef.value;
+		return core.t(key, params);
+	}
+	return {
+		locale: localeRef,
+		get fallbackLocale() {
+			return core.fallbackLocale;
+		},
+		get availableLocales() {
+			return core.availableLocales;
+		},
+		t: translate,
+		setLocale(locale) {
+			core.setLocale(locale);
+		},
+		getLocale() {
+			return localeRef.value;
+		},
+		onLocaleChange(callback) {
+			return core.onLocaleChange(callback);
+		},
+		getLocaleDir(locale) {
+			return core.getLocaleDir(locale);
+		},
+		getLocaleName(locale) {
+			return core.getLocaleName(locale);
+		},
+		localeDir,
+		localeName
+	};
+}
+function defineLocale$1(definition) {
+	const result = defineLocale(definition);
+	localeRef.value = getLocale();
+	return result;
+}
+function t$1(key, params) {
+	return t(key, params);
+}
+function setLocale$1(locale) {
+	setLocale(locale);
+}
+function getLocale$1() {
+	return localeRef.value;
+}
+function onLocaleChange$1(callback) {
+	return onLocaleChange(callback);
+}
+function getLocaleDir$1(locale) {
+	return getLocaleDir(locale);
+}
+function getLocaleName$1(locale) {
+	return getLocaleName(locale);
+}
+function getRegisteredLocales$1() {
+	return getRegisteredLocales();
+}
+function detectLocale$1(acceptLanguage) {
+	return detectLocale(acceptLanguage);
+}
+function detectBrowserLocale$1() {
+	return detectBrowserLocale();
+}
+function addLocale$1(code, messages, options) {
+	addLocale(code, messages, options);
+}
+function mergeLocale$1(code, messages) {
+	mergeLocale(code, messages);
+}
+function clearLocales$1() {
+	clearLocales();
+	localeRef.value = getLocale();
+}
+function getI18nConfig$1() {
+	return getI18nConfig();
+}
+function setI18nConfig$1(config) {
+	setI18nConfig(config);
+}
+function localizePath$1(path, locale) {
+	return localizePath(path, locale);
+}
+function switchLocalePath$1(newLocale, currentPath) {
+	return switchLocalePath(newLocale, currentPath);
+}
+function getDefaultLocale$1() {
+	return getDefaultLocale();
+}
+function extractLocaleFromPath$1(path) {
+	return extractLocaleFromPath(path);
+}
+function useSwitchLocalePath() {
+	return computed(() => (newLocale) => {
+		return switchLocalePath(newLocale, typeof _global$1.window !== "undefined" ? _global$1.window.location.pathname : "/");
+	});
+}
+function useLocalePath() {
+	return computed(() => (path, locale) => {
+		return localizePath(path, locale || localeRef.value);
+	});
+}
+//#endregion
+//#region src/router.ts
+function createUbeanRouter(options) {
+	const base = options.base || "/";
+	const router = createRouter({
+		history: options.ssr ? createMemoryHistory(base) : createWebHistory(base),
+		routes: options.routes,
+		scrollBehavior(_to, _from, savedPosition) {
+			if (savedPosition) return savedPosition;
+			if (_to.hash) return {
+				el: _to.hash,
+				behavior: "smooth"
+			};
+			return { top: 0 };
+		}
+	});
+	if (options.setup) options.setup(router);
+	if (options.ssr && options.initialUrl) router.push(options.initialUrl);
+	return router;
+}
+//#endregion
+//#region src/cache-views.ts
+/**
+* Page cache (keep-alive) store — a module-level singleton.
+*
+* ubean uses flat single-layer layout, so all page components are direct
+* children of a single layout's `<RouterView>`. A `<keep-alive :include="...">`
+* wraps that `<RouterView>`; the `include` list is the reactive array exposed
+* here. Caching is keyed by the page's **route name**, which is injected as the
+* component `name` at render time (see `createLayoutWrapper` in `app.ts`).
+*
+* In addition to the `include` list, an `exclude` list is also maintained.
+* `<keep-alive :exclude="...">` skips caching for matched names even if they
+* appear in `include`. This is useful for the "reload current page" pattern:
+* temporarily push a route name into `exclude`, wait a tick, then remove it —
+* the cached instance is pruned and the page remounts fresh on next visit.
+*
+* Usage:
+*   // declarative (compile-time): enable caching for a page
+*   definePage({ cache: true })
+*
+*   // runtime: toggle caching imperatively
+*   import { enablePageCache, disablePageCache } from '@ubean/runtime';
+*   enablePageCache('DashboardIndex');
+*   disablePageCache('DashboardIndex');
+*
+*   // reload a cached page (clears its instance, forces remount)
+*   import { resetRouteCache } from '@ubean/runtime';
+*   await resetRouteCache('DashboardIndex');
+*/
+const _g = globalThis;
+const _cachedViewNames = _g.__ubeanCachedViewNames ??= ref([]);
+const _excludedViewNames = _g.__ubeanExcludedViewNames ??= ref([]);
+const _cacheEnabled = _g.__ubeanCacheEnabled ??= ref(true);
+/**
+* Composable for reactive access to the page cache store.
+*
+* Safe to call inside any component `setup()`; the returned computeds are
+* tracked by the rendering effect so `<keep-alive :include>` stays in sync.
+*/
+function useCacheViews() {
+	return {
+		cachedViews: computed(() => _cacheEnabled.value ? _cachedViewNames.value : []),
+		cachedViewNames: computed(() => _cachedViewNames.value),
+		excludedViews: computed(() => _excludedViewNames.value),
+		enabled: computed(() => _cacheEnabled.value),
+		enable: () => {
+			_cacheEnabled.value = true;
+		},
+		disable: () => {
+			_cacheEnabled.value = false;
+		},
+		add: (name) => {
+			if (name && !_cachedViewNames.value.includes(name)) _cachedViewNames.value = [..._cachedViewNames.value, name];
+		},
+		remove: (name) => {
+			_cachedViewNames.value = _cachedViewNames.value.filter((n) => n !== name);
+		},
+		has: (name) => _cachedViewNames.value.includes(name),
+		clear: () => {
+			_cachedViewNames.value = [];
+		},
+		addExclude: (name) => {
+			if (name && !_excludedViewNames.value.includes(name)) _excludedViewNames.value = [..._excludedViewNames.value, name];
+		},
+		removeExclude: (name) => {
+			_excludedViewNames.value = _excludedViewNames.value.filter((n) => n !== name);
+		},
+		hasExclude: (name) => _excludedViewNames.value.includes(name),
+		clearExclude: () => {
+			_excludedViewNames.value = [];
+		}
+	};
+}
+/** Enable keep-alive caching for a specific page (by route name). */
+function enablePageCache(name) {
+	if (name && !_cachedViewNames.value.includes(name)) _cachedViewNames.value = [..._cachedViewNames.value, name];
+}
+/** Disable keep-alive caching for a specific page (by route name). */
+function disablePageCache(name) {
+	_cachedViewNames.value = _cachedViewNames.value.filter((n) => n !== name);
+}
+/**
+* Temporarily exclude a page from keep-alive (forces its cached instance
+* to be pruned on next render). Pair with `includePageCache()` to restore.
+*
+* Useful for the "reload current page" pattern: push the route name into
+* the exclude list, wait a tick, then remove it — the cached instance is
+* pruned and the page remounts fresh on next render.
+*/
+function excludePageCache(name) {
+	if (name && !_excludedViewNames.value.includes(name)) _excludedViewNames.value = [..._excludedViewNames.value, name];
+}
+/** Remove a route name from the cache exclude list (restores caching). */
+function includePageCache(name) {
+	_excludedViewNames.value = _excludedViewNames.value.filter((n) => n !== name);
+}
+/** Whether a specific page is currently excluded from cache. */
+function isPageExcluded(name) {
+	return _excludedViewNames.value.includes(name);
+}
+/**
+* Reload a cached page by temporarily excluding it from keep-alive.
+*
+* Pattern (mirrors `routeStore.resetRouteCache` in soybean-unify):
+*   1. Push the route name into the exclude list (prunes cached instance).
+*   2. Wait one tick (let `<keep-alive>` reconcile).
+*   3. Remove the route name from the exclude list.
+*
+* The page's `definePage({ cache: true })` declaration (or a prior
+* `enablePageCache(name)`) is still in effect, so the page will be re-cached
+* on the next visit.
+*
+* @param name Route name. If omitted, uses the current route's name
+*             (requires a Vue component setup context — fall back to
+*             passing the name explicitly from outside Vue).
+* @param delay Milliseconds to wait between exclude and include. Defaults
+*              to 50ms (matches soybean-unify's pattern).
+*/
+async function resetRouteCache(name, delay = 50) {
+	const target = name;
+	if (!target) return;
+	if (!_cachedViewNames.value.includes(target)) return;
+	excludePageCache(target);
+	await new Promise((resolve) => setTimeout(resolve, delay));
+	includePageCache(target);
+}
+/**
+* Invalidate cached page instance(s).
+*
+* - With a `name`: removes that page from the cache (its instance is pruned
+*   on next navigation).
+* - Without a `name`: clears all cached pages.
+*
+* Note: the page will be re-cached on next visit if its `definePage({ cache: true })`
+* is still in effect or `enablePageCache(name)` is called again.
+*/
+function invalidatePageCache(name) {
+	if (name) disablePageCache(name);
+	else _cachedViewNames.value = [];
+}
+/** Whether a specific page is currently cached. */
+function isPageCached(name) {
+	return _cachedViewNames.value.includes(name);
+}
+/** Whether page caching is globally enabled. */
+function isCacheEnabled() {
+	return _cacheEnabled.value;
+}
+/** Reactive ref of cached route names — for advanced use cases. */
+function getCachedViewNames() {
+	return _cachedViewNames;
+}
+/** Reactive ref of excluded route names — for advanced use cases. */
+function getExcludedViewNames() {
+	return _excludedViewNames;
+}
+/** Reactive ref of the global cache-enabled flag. */
+function getCacheEnabled() {
+	return _cacheEnabled;
+}
+/**
+* Seed the cache include list from route metadata.
+*
+* Called once during app bootstrap (`createUbeanApp`) to honor pages that
+* declared `definePage({ cache: true })`. Routes without `meta.cache` are
+* left untouched so runtime toggling remains possible.
+*/
+function initCachedViewsFromRoutes(routes) {
+	const initial = [];
+	for (const route of routes) if (route.meta?.cache === true && typeof route.name === "string" && route.name) {
+		if (!initial.includes(route.name)) initial.push(route.name);
+	}
+	if (initial.length > 0) {
+		const existing = new Set(_cachedViewNames.value);
+		for (const name of initial) if (!existing.has(name)) existing.add(name);
+		_cachedViewNames.value = [...existing];
+	}
+}
+//#endregion
+//#region src/page-runtime.ts
+/**
+* Global page runtime config — animation mode + reload signal.
+*
+* These module-level singletons mirror the patterns found in soybean-unify's
+* `themeStore.pageAnimateMode` and `appStore.reloadSignal`:
+*
+*   - `pageAnimateMode` is a global transition name applied to every
+*     `<PageView />` unless overridden by the `transition` prop or
+*     `route.meta.transition`. Set to `'none'` (or empty string) to disable
+*     transitions globally.
+*
+*   - `reloadSignal` is a counter that increments each time `reloadPage()` is
+*     called. `<PageView />` watches this counter (via `:key`) and remounts
+*     the current page when it changes — combined with `resetRouteCache()` to
+*     prune the cached keep-alive instance so the remount is fresh.
+*
+* These are intentionally framework-provided singletons (not pinia stores)
+* because ubean ships without a state management library and the values are
+* globally unique by nature.
+*/
+const _pageTransitionName = ref("");
+const _reloadCounter = ref(0);
+/**
+* Composable for reactive access to the global page transition name.
+*
+* Used by `<PageView />` as the fallback transition name when neither the
+* `transition` prop nor `route.meta.transition` is set.
+*
+* Layout components can also read this to display a settings UI:
+*
+* ```ts
+* const transition = usePageTransition();
+* // transition.name.value === 'fade-slide'
+* transition.set('zoom-fadein');
+* transition.clear();
+* ```
+*/
+function usePageTransition() {
+	return {
+		name: computed(() => _pageTransitionName.value),
+		set: (name) => {
+			_pageTransitionName.value = name === "none" ? "" : name;
+		},
+		clear: () => {
+			_pageTransitionName.value = "";
+		},
+		enabled: computed(() => _pageTransitionName.value !== "")
+	};
+}
+/** Imperatively set the global page transition name. */
+function setPageTransition(name) {
+	_pageTransitionName.value = name === "none" ? "" : name;
+}
+/** Imperatively clear the global page transition name (disables transitions). */
+function clearPageTransition() {
+	_pageTransitionName.value = "";
+}
+/** Reactive ref of the global transition name — for advanced use cases. */
+function getPageTransitionName() {
+	return _pageTransitionName;
+}
+/**
+* Internal flag — set to `true` while a reload is in progress so consumers
+* can show a loading indicator if they wish.
+*/
+const _reloading = ref(false);
+/**
+* Composable for reactive access to the page reload signal.
+*
+* `<PageView />` uses the returned `counter` as part of its render key, so
+* each `reload()` call forces the current page to remount. Combined with
+* `resetRouteCache()` (called internally), the cached keep-alive instance is
+* pruned first, so the remount is fresh — equivalent to the
+* `v-if="appStore.reloadSignal"` pattern in soybean-unify's layout-content.
+*
+* Usage from any component:
+*
+* ```ts
+* const { reload } = useReloadSignal();
+* async function onReloadClick() {
+*   await reload(); // reloads the current page
+* }
+* ```
+*
+* @param routeNameGetter Optional function returning the current route name.
+*                        If provided, used to call `resetRouteCache(name)`.
+*                        If omitted, `reload()` only bumps the counter.
+*/
+function useReloadSignal(routeNameGetter) {
+	return {
+		counter: computed(() => _reloadCounter.value),
+		reloading: computed(() => _reloading.value),
+		reload: async (routeName, duration = 300) => {
+			_reloading.value = true;
+			try {
+				const name = routeName ?? routeNameGetter?.();
+				if (name) await resetRouteCache(name, 50);
+				await new Promise((resolve) => setTimeout(resolve, duration));
+				_reloadCounter.value++;
+			} finally {
+				_reloading.value = false;
+			}
+		}
+	};
+}
+/**
+* Imperatively trigger a page reload.
+*
+* - `name`: route name to reload. If provided, the cached keep-alive instance
+*   is pruned first via `resetRouteCache(name)`. If omitted, only the reload
+*   counter is bumped (forces remount but does not prune cache).
+* - `duration`: milliseconds to wait for transition/cleanup. Defaults to 300.
+*/
+async function reloadPage(name, duration = 300) {
+	_reloading.value = true;
+	try {
+		if (name) await resetRouteCache(name, 50);
+		await new Promise((resolve) => setTimeout(resolve, duration));
+		_reloadCounter.value++;
+	} finally {
+		_reloading.value = false;
+	}
+}
+/** Reactive ref of the reload counter — for advanced use cases. */
+function getReloadCounter() {
+	return _reloadCounter;
+}
+/** Whether a reload is currently in progress. */
+function isReloading() {
+	return _reloading.value;
+}
+//#endregion
+//#region src/view-transitions.ts
+const _global = globalThis;
+let _typesSupported = null;
+function supportsTransitionTypes() {
+	if (_typesSupported !== null) return _typesSupported;
+	if (!supportsViewTransitions()) {
+		_typesSupported = false;
+		return false;
+	}
+	try {
+		let calledWithObject = false;
+		const doc = _global.document;
+		const orig = doc.startViewTransition;
+		doc.startViewTransition = function(opts) {
+			if (opts && typeof opts === "object" && "update" in opts) calledWithObject = true;
+			return {
+				finished: Promise.resolve(),
+				ready: Promise.resolve(),
+				updateCallbackDone: Promise.resolve(),
+				skipTransition() {}
+			};
+		};
+		try {
+			doc.startViewTransition({
+				update: () => {},
+				types: ["test"]
+			});
+		} catch {}
+		doc.startViewTransition = orig;
+		_typesSupported = calledWithObject;
+	} catch {
+		_typesSupported = false;
+	}
+	return _typesSupported;
+}
+function supportsViewTransitions() {
+	if (typeof _global.document === "undefined") return false;
+	return typeof _global.document.startViewTransition === "function";
+}
+async function withViewTransition(callback, options = {}) {
+	const { enabled = true, types } = options;
+	if (!enabled || !supportsViewTransitions()) return callback();
+	const doc = _global.document;
+	const useTypesApi = types && types.length > 0 && supportsTransitionTypes();
+	let result;
+	let callbackError;
+	let callbackFailed = false;
+	const updateCallback = async () => {
+		try {
+			result = await callback();
+		} catch (e) {
+			callbackFailed = true;
+			callbackError = e;
+			throw e;
+		}
+	};
+	let transition;
+	if (useTypesApi) transition = doc.startViewTransition({
+		update: updateCallback,
+		types
+	});
+	else transition = doc.startViewTransition(updateCallback);
+	try {
+		await transition.finished;
+	} catch (err) {
+		if (callbackFailed) throw callbackError;
+		throw err;
+	}
+	if (callbackFailed) throw callbackError;
+	return result;
+}
+function getNavigationType() {
+	try {
+		const nav = _global.navigation;
+		if (nav?.currentEntry && nav?.transitionType) return nav.transitionType;
+	} catch {}
+	return "push";
+}
+function useViewTransitionState(name) {
+	return { style: `view-transition-name: ${name};` };
+}
+//#endregion
+//#region src/app.ts
+const PAGE_KEY = Symbol("ubean-page");
+const TRANSITION_KEY = Symbol("ubean-transition");
+const SSR_KEY = Symbol("ubean-ssr");
+function createLayoutWrapper(resolveLayoutComponent, defaultLayout) {
+	const layoutCache = /* @__PURE__ */ new Map();
+	const layoutComp = shallowRef(null);
+	const currentLayoutName = ref(null);
+	async function loadLayout(name) {
+		const resolved = name === void 0 ? defaultLayout : name;
+		if (resolved === false || resolved == null) {
+			layoutComp.value = null;
+			return;
+		}
+		if (layoutCache.has(resolved)) {
+			layoutComp.value = layoutCache.get(resolved) || null;
+			return;
+		}
+		const comp = await resolveLayoutComponent(resolved);
+		if (comp) {
+			const raw = markRaw(comp);
+			layoutCache.set(resolved, raw);
+			layoutComp.value = raw;
+		} else {
+			layoutCache.set(resolved, null);
+			layoutComp.value = null;
+		}
+	}
+	return defineComponent({
+		name: "UbeanLayoutView",
+		setup() {
+			const route = useRoute();
+			watchEffect(() => {
+				const layoutName = route.meta.layout;
+				if (layoutName !== currentLayoutName.value) {
+					currentLayoutName.value = layoutName === void 0 ? defaultLayout : layoutName;
+					loadLayout(currentLayoutName.value);
+				}
+			});
+			return () => {
+				if (!layoutComp.value) return h(PageView);
+				return h(layoutComp.value);
+			};
+		}
+	});
+}
+/**
+* PageView — a globally-registered component that renders the matched route
+* page, wrapped with `<Transition>` and `<KeepAlive>`.
+*
+* Layouts use `<PageView />` (instead of `<slot />`) to render the matched
+* page. This follows vue-router's v-slot pattern, mirroring soybean-unify's
+* `layouts/modules/layout-content/index.vue`:
+*
+* ```html
+* <RouterView v-slot="{ Component, route }">
+*   <Transition :name="pageAnimateMode" mode="out-in">
+*     <KeepAlive :include="cachedRoutes" :exclude="excludeCachedRoutes">
+*       <component :is="Component" v-if="reloadSignal" :key="tabId" />
+*     </KeepAlive>
+*   </Transition>
+* </RouterView>
+* ```
+*
+* In ubean, the equivalents are:
+*   - `pageAnimateMode` → global `usePageTransition()` ref + `transition` prop + `route.meta.transition`
+*   - `cachedRoutes` / `excludeCachedRoutes` → `useCacheViews().cachedViews` / `excludedViews`
+*   - `reloadSignal` → `useReloadSignal().counter` (incremented by `reloadPage()`)
+*   - `tabId` → `reloadKey` prop + reload counter (forces remount when changed)
+*
+* Props:
+* - `transition`: transition name (string) or `false` to disable.
+*   Priority: prop > `route.meta.transition` > global `usePageTransition()`.
+* - `reloadKey`: a reactive key — changing it forces remount (reload).
+*   When omitted, falls back to `route.fullPath` + global reload counter.
+* - `mode`: Vue `<Transition>` mode. Defaults to `'out-in'`.
+*
+* On SSR, KeepAlive and Transition are skipped (client-only concepts).
+*/
+const PageView = defineComponent({
+	name: "PageView",
+	props: {
+		transition: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		reloadKey: {
+			type: [String, Number],
+			default: void 0
+		},
+		mode: {
+			type: String,
+			default: "out-in"
+		}
+	},
+	setup(props) {
+		const { cachedViews, excludedViews } = useCacheViews();
+		const globalTransition = usePageTransition();
+		const { counter: reloadCounter } = useReloadSignal();
+		const ssr = inject(SSR_KEY, false);
+		return () => {
+			return h(RouterView, null, { default: ({ Component, route }) => {
+				if (!Component) return null;
+				if (ssr) return Component;
+				const comp = Component.type;
+				const componentProps = Component.props || {};
+				const routeTransition = route.meta?.transition;
+				const transitionName = props.transition === false ? void 0 : props.transition || routeTransition || globalTransition.name.value || void 0;
+				const pageVNode = h(comp, {
+					...componentProps,
+					key: props.reloadKey ?? `${route.fullPath}#${reloadCounter.value}`
+				});
+				const keepAliveProps = { include: cachedViews.value };
+				if (excludedViews.value.length > 0) keepAliveProps.exclude = excludedViews.value;
+				const keepAliveVNode = h(KeepAlive, keepAliveProps, { default: () => pageVNode });
+				if (transitionName) return h(Transition, {
+					name: transitionName,
+					mode: props.mode
+				}, { default: () => keepAliveVNode });
+				return keepAliveVNode;
+			} });
+		};
+	}
+});
+const Link = defineComponent({
+	name: "Link",
+	props: {
+		to: {
+			type: [String, Object],
+			default: void 0
+		},
+		href: {
+			type: String,
+			default: void 0
+		},
+		replace: {
+			type: Boolean,
+			default: false
+		},
+		prefetch: {
+			type: Boolean,
+			default: false
+		},
+		activeClass: {
+			type: String,
+			default: "router-link-active"
+		},
+		exactActiveClass: {
+			type: String,
+			default: "router-link-exact-active"
+		},
+		noActiveClass: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(props, { slots, attrs }) {
+		const resolvedTo = computed(() => {
+			const path = props.to ?? props.href ?? "";
+			if (typeof path === "string" && (path.startsWith("http") || path.startsWith("//") || path.startsWith("#"))) return path;
+			return localizePath$1(path);
+		});
+		const isExternal = computed(() => {
+			const path = String(resolvedTo.value);
+			return path.startsWith("http") || path.startsWith("//") || path.startsWith("#");
+		});
+		return () => {
+			if (isExternal.value) return h("a", {
+				...attrs,
+				href: resolvedTo.value,
+				target: "_blank",
+				rel: "noopener noreferrer"
+			}, slots.default ? slots.default() : void 0);
+			return h(RouterLink, {
+				...attrs,
+				to: resolvedTo.value,
+				replace: props.replace,
+				activeClass: props.noActiveClass ? "" : props.activeClass,
+				exactActiveClass: props.noActiveClass ? "" : props.exactActiveClass
+			}, slots.default);
+		};
+	}
+});
+const Head$1 = Head;
+function createRootComponent(LayoutWrapper, page, transitionOpts, isSSR) {
+	return defineComponent({
+		name: isSSR ? "UbeanSSRApp" : "UbeanAppRoot",
+		setup() {
+			provide(PAGE_KEY, page);
+			provide(TRANSITION_KEY, transitionOpts);
+			provide(SSR_KEY, isSSR);
+			return () => h(LayoutWrapper);
+		}
+	});
+}
+function createUbeanApp(options) {
+	if (!options.head) throw new Error("[ubean] createUbeanApp requires a head instance from @unhead/vue/client");
+	const initial = options.initialPage || {
+		component: "",
+		props: {},
+		params: {},
+		url: "/"
+	};
+	const head = options.head;
+	const transitionOpts = options.viewTransitions === false ? { enabled: false } : options.viewTransitions === true || options.viewTransitions == null ? { enabled: true } : options.viewTransitions;
+	const page = reactive({ ...initial });
+	const router = createUbeanRouter({
+		routes: options.routes,
+		ssr: false,
+		setup: options.routerSetup
+	});
+	const LayoutWrapper = createLayoutWrapper(options.resolveLayoutComponent, options.defaultLayout || null);
+	initCachedViewsFromRoutes(options.routes);
+	const RootComponent = createRootComponent(LayoutWrapper, page, transitionOpts, false);
+	const app = options.hydrate ? createSSRApp(RootComponent) : createApp(RootComponent);
+	app.use(head);
+	app.use(router);
+	app.component("Link", Link);
+	app.component("PageView", PageView);
+	app.config.globalProperties.$ubean = {
+		page,
+		head,
+		router
+	};
+	return {
+		app,
+		router,
+		head,
+		page
+	};
+}
+function createUbeanSSRApp(initialPage, options) {
+	if (!options.head) throw new Error("[ubean] createUbeanSSRApp requires a head instance from @unhead/vue/server");
+	const head = options.head;
+	const page = reactive({ ...initialPage });
+	const router = createUbeanRouter({
+		routes: options.routes,
+		ssr: true,
+		initialUrl: initialPage.url,
+		setup: options.routerSetup
+	});
+	const LayoutWrapper = createLayoutWrapper(options.resolveLayoutComponent, options.defaultLayout || null);
+	initCachedViewsFromRoutes(options.routes);
+	const app = createSSRApp(createRootComponent(LayoutWrapper, page, { enabled: false }, true));
+	app.use(head);
+	app.use(router);
+	app.component("Link", Link);
+	app.component("PageView", PageView);
+	app.config.globalProperties.$ubean = {
+		page,
+		head,
+		router
+	};
+	return {
+		app,
+		router,
+		head
+	};
+}
+function usePage() {
+	const route = useRoute();
+	const pageData = inject(PAGE_KEY, null);
+	return reactive({
+		url: computed(() => route.fullPath),
+		params: computed(() => route.params),
+		query: computed(() => route.query),
+		meta: computed(() => route.meta),
+		props: computed(() => pageData?.props || {}),
+		component: computed(() => route.meta.pageName || pageData?.component || ""),
+		errors: computed(() => pageData?.errors || null)
+	});
+}
+function useRouter$1() {
+	const router = useRouter();
+	return {
+		...router,
+		push: (url, opts) => opts?.replace ? router.replace(url) : router.push(url),
+		replace: (url) => router.replace(url),
+		back: () => router.back(),
+		forward: () => router.forward(),
+		refresh: () => router.go(0),
+		get current() {
+			return router.currentRoute.value;
+		},
+		get navigating() {
+			return false;
+		}
+	};
+}
+function useViewTransition() {
+	const opts = inject(TRANSITION_KEY, { enabled: true });
+	return {
+		enabled: opts.enabled !== false && supportsViewTransitions(),
+		supports: supportsViewTransitions(),
+		options: opts
+	};
+}
+//#endregion
+export { setI18nConfig$1 as $, initCachedViewsFromRoutes as A, defineLocale$1 as B, disablePageCache as C, getCachedViewNames as D, getCacheEnabled as E, resetRouteCache as F, getI18nConfig$1 as G, detectLocale$1 as H, useCacheViews as I, getLocaleName$1 as J, getLocale$1 as K, createUbeanRouter as L, isCacheEnabled as M, isPageCached as N, getExcludedViewNames as O, isPageExcluded as P, onLocaleChange$1 as Q, addLocale$1 as R, useReloadSignal as S, excludePageCache as T, extractLocaleFromPath$1 as U, detectBrowserLocale$1 as V, getDefaultLocale$1 as W, localizePath$1 as X, getRegisteredLocales$1 as Y, mergeLocale$1 as Z, getReloadCounter as _, createUbeanSSRApp as a, useSwitchLocalePath as at, setPageTransition as b, useSeoMeta as c, getNavigationType as d, setLocale$1 as et, supportsViewTransitions as f, getPageTransitionName as g, clearPageTransition as h, createUbeanApp as i, useLocalePath as it, invalidatePageCache as j, includePageCache as k, useUnheadHead as l, withViewTransition as m, Link as n, t$1 as nt, usePage as o, useViewTransitionState as p, getLocaleDir$1 as q, PageView as r, useI18n$1 as rt, useRouter$1 as s, Head$1 as t, switchLocalePath$1 as tt, useViewTransition as u, isReloading as v, enablePageCache as w, usePageTransition as x, reloadPage as y, clearLocales$1 as z };