@ubean/runtime 0.1.2 → 0.1.4

package/dist/app.d.ts

@@ -0,0 +1,2 @@
+import { a as UbeanAppOptions, c as createUbeanApp, d as useRouter, f as useSeoMeta, i as UbeanAppInstance, l as createUbeanSSRApp, m as useViewTransition, n as Link, o as UbeanRouter, p as useUnheadHead, r as PageView, s as VueHeadClient, t as Head, u as usePage } from "./app-CDOvFfdJ.js";
+export { Head, Link, PageView, UbeanAppInstance, UbeanAppOptions, UbeanRouter, type VueHeadClient, createUbeanApp, createUbeanSSRApp, useUnheadHead as useHead, usePage, useRouter, useSeoMeta, useViewTransition };

package/dist/app.js

@@ -0,0 +1,2 @@
+import { a as createUbeanSSRApp, c as useSeoMeta, i as createUbeanApp, l as useUnheadHead, n as Link, o as usePage, r as PageView, s as useRouter, t as Head, u as useViewTransition } from "./app-dx92OPRP.js";
+export { Head, Link, PageView, createUbeanApp, createUbeanSSRApp, useUnheadHead as useHead, usePage, useRouter, useSeoMeta, useViewTransition };

package/dist/define-app.d.ts

@@ -0,0 +1,82 @@
+import { t as ViewTransitionOptions } from "./view-transitions-DRrLaRHL.js";
+import { App, Component, Plugin } from "vue";
+import { Router } from "vue-router";
+import { PageHead } from "@ubean/types";
+//#region src/define-app.d.ts
+interface AppPluginConfig {
+  plugin: Plugin | [Plugin, ...any[]];
+  mode?: 'all' | 'client' | 'server';
+}
+/**
+ * Router 钩子配置 — 暴露 vue-router 的导航守卫注册入口。
+ *
+ * `setup(router)` 在 router 实例创建后、`app.use(router)` 之前调用,
+ * 因此守卫能拦截首次导航(包括 SSR 的初始 URL push)。
+ *
+ * Client 和 SSR 都会执行,适合做鉴权、埋点、进度条等逻辑。
+ *
+ * @example
+ * ```ts
+ * defineApp({
+ *   router: {
+ *     setup(router) {
+ *       router.beforeEach((to, from) => {
+ *         if (to.meta.requiresAuth && !isAuthenticated()) {
+ *           return '/login';
+ *         }
+ *       });
+ *       router.afterEach((to) => {
+ *         analytics.track('page_view', { path: to.fullPath });
+ *       });
+ *     }
+ *   }
+ * });
+ * ```
+ */
+interface RouterConfig {
+  /**
+   * 在 router 创建后、初始导航前调用。
+   * 用于注册 `beforeEach` / `beforeResolve` / `afterEach` 等守卫。
+   *
+   * 注意:setup 必须同步注册守卫(虽然守卫本身可以返回 Promise)。
+   * 不要在 setup 中执行异步操作(如请求 API),因为这会延迟首次导航。
+   */
+  setup?: (router: Router) => void;
+}
+interface DefineAppOptions {
+  plugins?: Array<Plugin | [Plugin, ...any[]] | AppPluginConfig>;
+  globalComponents?: Record<string, Component>;
+  provides?: Record<string | symbol, unknown>;
+  head?: PageHead;
+  rootId?: string;
+  rootAttrs?: Record<string, string>;
+  /**
+   * 路由钩子配置,用于注册 vue-router 的导航守卫。
+   * 在 Client 和 SSR 都会执行。
+   */
+  router?: RouterConfig;
+  onAppCreated?: (app: App) => void | Promise<void>;
+  onClientReady?: (app: App) => void | Promise<void>;
+  errorComponent?: Component;
+  loadingComponent?: Component;
+  viewTransitions?: boolean | ViewTransitionOptions;
+}
+interface ResolvedAppConfig {
+  plugins: AppPluginConfig[];
+  globalComponents: Record<string, Component>;
+  provides: Record<string | symbol, unknown>;
+  head?: PageHead;
+  rootId: string;
+  rootAttrs: Record<string, string>;
+  router?: RouterConfig;
+  onAppCreated?: (app: App) => void | Promise<void>;
+  onClientReady?: (app: App) => void | Promise<void>;
+  errorComponent?: Component;
+  loadingComponent?: Component;
+  viewTransitions?: boolean | ViewTransitionOptions;
+}
+declare function defineApp(options: DefineAppOptions): ResolvedAppConfig;
+declare function applyAppConfig(app: App, config: ResolvedAppConfig, mode: 'client' | 'server'): void;
+declare function createDefaultAppConfig(): ResolvedAppConfig;
+//#endregion
+export { AppPluginConfig, DefineAppOptions, ResolvedAppConfig, RouterConfig, applyAppConfig, createDefaultAppConfig, defineApp };

package/dist/define-app.js

@@ -0,0 +1,44 @@
+//#region src/define-app.ts
+function defineApp(options) {
+	const plugins = [];
+	if (options.plugins) for (const p of options.plugins) if (Array.isArray(p)) plugins.push({
+		plugin: p,
+		mode: "all"
+	});
+	else if (typeof p === "object" && "plugin" in p) plugins.push(p);
+	else plugins.push({
+		plugin: p,
+		mode: "all"
+	});
+	return {
+		plugins,
+		globalComponents: options.globalComponents || {},
+		provides: options.provides || {},
+		head: options.head,
+		rootId: options.rootId || "app",
+		rootAttrs: options.rootAttrs || {},
+		router: options.router,
+		onAppCreated: options.onAppCreated,
+		onClientReady: options.onClientReady,
+		errorComponent: options.errorComponent,
+		loadingComponent: options.loadingComponent,
+		viewTransitions: options.viewTransitions
+	};
+}
+function applyAppConfig(app, config, mode) {
+	for (const { plugin, mode: pluginMode = "all" } of config.plugins) if (pluginMode === "all" || pluginMode === mode) if (Array.isArray(plugin)) app.use(plugin[0], ...plugin.slice(1));
+	else app.use(plugin);
+	for (const [name, comp] of Object.entries(config.globalComponents)) app.component(name, comp);
+	for (const [key, value] of Object.entries(config.provides)) app.provide(key, value);
+}
+function createDefaultAppConfig() {
+	return {
+		plugins: [],
+		globalComponents: {},
+		provides: {},
+		rootId: "app",
+		rootAttrs: {}
+	};
+}
+//#endregion
+export { applyAppConfig, createDefaultAppConfig, defineApp };

package/dist/index.d.ts

@@ -0,0 +1,393 @@
+import { a as UbeanAppOptions, c as createUbeanApp, d as useRouter, f as useSeoMeta, g as createUbeanRouter, h as CreateUbeanRouterOptions, i as UbeanAppInstance, l as createUbeanSSRApp, m as useViewTransition, n as Link, p as useUnheadHead, r as PageView, s as VueHeadClient$1, t as Head, u as usePage } from "./app-CDOvFfdJ.js";
+import { a as withViewTransition, i as useViewTransitionState, n as getNavigationType, r as supportsViewTransitions, t as ViewTransitionOptions } from "./view-transitions-DRrLaRHL.js";
+import { AppPluginConfig, DefineAppOptions, ResolvedAppConfig, applyAppConfig, createDefaultAppConfig, defineApp } from "./define-app.js";
+import { VueHeadClient, injectHead } from "@unhead/vue";
+import { createHead as createClientHead } from "@unhead/vue/client";
+import { createHead as createServerHead } from "@unhead/vue/server";
+import { PageObject } from "@ubean/pages";
+import { App, Component, ComputedRef, Ref } from "vue";
+import { I18nConfig, LocaleChangeCallback, LocaleDefinition, LocaleMessages } from "@ubean/i18n";
+import { Input, RouteMeta } from "@ubean/types";
+import { DefineMetaResult, PageMeta } from "@ubean/routing";
+import { LinkTag, MetaTag, SeoMetadata } from "@ubean/seo";
+//#region src/client.d.ts
+declare function getInitialPageData<T = Record<string, unknown>>(): PageObject<T> | null;
+//#endregion
+//#region src/head.d.ts
+declare function useHeadInstance(): import("@unhead/vue").VueHeadClient;
+//#endregion
+//#region src/composables.d.ts
+interface UbeanVueContext {
+  __ubean_router?: import('vue-router').Router;
+  __ubean_data_cache?: DataCacheStore;
+}
+interface LinkProps {
+  href: string;
+  replace?: boolean;
+  prefetch?: boolean;
+}
+interface DataCacheStore {
+  get: <T = unknown>(key: string | symbol) => T | undefined;
+  set: <T = unknown>(key: string | symbol, value: T, tags?: string[]) => void;
+  has: (key: string | symbol) => boolean;
+  invalidate: (keyOrTag: string | symbol) => number;
+  clear: () => void;
+  subscribe: (fn: () => void) => () => void;
+  getTimestamp: (key: string | symbol) => number | undefined;
+}
+declare function createDataCacheStore(): DataCacheStore;
+interface UseAsyncDataOptions<T> {
+  key?: string;
+  tags?: string[];
+  lazy?: boolean;
+  server?: boolean;
+  default?: () => T;
+  transform?: (input: unknown) => T;
+}
+interface UseAsyncDataReturn<T> {
+  data: {
+    value: T | undefined;
+  };
+  error: {
+    value: Error | null;
+  };
+  loading: {
+    value: boolean;
+  };
+  refresh: () => Promise<void>;
+  invalidate: () => void;
+}
+declare function createUseAsyncData(store: DataCacheStore): <T = unknown>(keyOrFetcher: string | (() => Promise<T>), fetcherOrOptions?: (() => Promise<T>) | UseAsyncDataOptions<T>, options?: UseAsyncDataOptions<T>) => UseAsyncDataReturn<T>;
+declare function invalidateCache(store: DataCacheStore, keyOrTag: string): number;
+declare function clearCache(store: DataCacheStore): void;
+declare function defineDataKey(key: string): symbol;
+declare function createLinkHandler(ctx: UbeanVueContext): {
+  getProps: () => {};
+  navigate(href: string, opts?: {
+    replace?: boolean;
+  }): Promise<void>;
+  prefetch(_href: string): Promise<void>;
+};
+declare function extractPageData<T = Record<string, unknown>>(): PageObject<T> | null;
+declare function useServerData<T>(fetcher: () => Promise<T>): Promise<T>;
+declare function getInvalidatedKeysForAction(actionName: string, invalidationMap: Record<string, Array<string | symbol>>, store: DataCacheStore): number;
+//#endregion
+//#region src/cache-views.d.ts
+interface UseCacheViewsReturn {
+  /** Reactive list of cached route names — pass to `<keep-alive :include>`. */
+  cachedViews: ComputedRef<string[]>;
+  /** Reactive list of route names explicitly added to the cache. */
+  cachedViewNames: ComputedRef<string[]>;
+  /** Reactive list of route names excluded from cache — pass to `<keep-alive :exclude>`. */
+  excludedViews: ComputedRef<string[]>;
+  /** Whether page caching is globally enabled. */
+  enabled: ComputedRef<boolean>;
+  /** Enable page caching globally. */
+  enable: () => void;
+  /** Disable page caching globally (purges keep-alive immediately). */
+  disable: () => void;
+  /** Add a route name to the cache include list. */
+  add: (name: string) => void;
+  /** Remove a route name from the cache include list (prunes its instance). */
+  remove: (name: string) => void;
+  /** Whether a route name is currently in the cache include list. */
+  has: (name: string) => boolean;
+  /** Remove all route names from the cache include list. */
+  clear: () => void;
+  /** Add a route name to the cache exclude list (forces prune on next render). */
+  addExclude: (name: string) => void;
+  /** Remove a route name from the cache exclude list. */
+  removeExclude: (name: string) => void;
+  /** Whether a route name is currently in the cache exclude list. */
+  hasExclude: (name: string) => boolean;
+  /** Clear the cache exclude list. */
+  clearExclude: () => void;
+}
+/**
+ * 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.
+ */
+declare function useCacheViews(): UseCacheViewsReturn;
+/** Enable keep-alive caching for a specific page (by route name). */
+declare function enablePageCache(name: string): void;
+/** Disable keep-alive caching for a specific page (by route name). */
+declare function disablePageCache(name: string): void;
+/**
+ * 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.
+ */
+declare function excludePageCache(name: string): void;
+/** Remove a route name from the cache exclude list (restores caching). */
+declare function includePageCache(name: string): void;
+/** Whether a specific page is currently excluded from cache. */
+declare function isPageExcluded(name: string): boolean;
+/**
+ * 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).
+ */
+declare function resetRouteCache(name?: string, delay?: number): Promise<void>;
+/**
+ * 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.
+ */
+declare function invalidatePageCache(name?: string): void;
+/** Whether a specific page is currently cached. */
+declare function isPageCached(name: string): boolean;
+/** Whether page caching is globally enabled. */
+declare function isCacheEnabled(): boolean;
+/** Reactive ref of cached route names — for advanced use cases. */
+declare function getCachedViewNames(): Ref<string[]>;
+/** Reactive ref of excluded route names — for advanced use cases. */
+declare function getExcludedViewNames(): Ref<string[]>;
+/** Reactive ref of the global cache-enabled flag. */
+declare function getCacheEnabled(): Ref<boolean>;
+/**
+ * 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.
+ */
+declare function initCachedViewsFromRoutes(routes: Array<{
+  name?: string | symbol;
+  meta?: {
+    cache?: boolean;
+  };
+}>): void;
+//#endregion
+//#region src/page-runtime.d.ts
+interface UsePageTransitionReturn {
+  /** Reactive transition name. Empty string means "no transition". */
+  name: ComputedRef<string>;
+  /** Set the global transition name. Use '' or 'none' to disable. */
+  set: (name: string) => void;
+  /** Clear the global transition name (disables transitions). */
+  clear: () => void;
+  /** Whether a transition is currently configured. */
+  enabled: ComputedRef<boolean>;
+}
+/**
+ * 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();
+ * ```
+ */
+declare function usePageTransition(): UsePageTransitionReturn;
+/** Imperatively set the global page transition name. */
+declare function setPageTransition(name: string): void;
+/** Imperatively clear the global page transition name (disables transitions). */
+declare function clearPageTransition(): void;
+/** Reactive ref of the global transition name — for advanced use cases. */
+declare function getPageTransitionName(): Ref<string>;
+interface UseReloadSignalReturn {
+  /** Reactive counter that increments on each `reloadPage()` call. */
+  counter: ComputedRef<number>;
+  /** Whether a reload is currently in progress. */
+  reloading: ComputedRef<boolean>;
+  /** Trigger a reload of the current page. */
+  reload: (routeName?: string, duration?: number) => Promise<void>;
+}
+/**
+ * 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.
+ */
+declare function useReloadSignal(routeNameGetter?: () => string | undefined | null): UseReloadSignalReturn;
+/**
+ * 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.
+ */
+declare function reloadPage(name?: string, duration?: number): Promise<void>;
+/** Reactive ref of the reload counter — for advanced use cases. */
+declare function getReloadCounter(): Ref<number>;
+/** Whether a reload is currently in progress. */
+declare function isReloading(): boolean;
+//#endregion
+//#region src/page-macro.d.ts
+declare function definePage(_meta: PageMeta): void;
+declare function defineMeta(_meta: Partial<RouteMeta>): DefineMetaResult | void;
+declare function defineMiddleware<_I extends Input>(_handler: any): void;
+//#endregion
+//#region src/router-location.d.ts
+interface RouteLocationRaw {
+  name?: string;
+  path?: string;
+  params?: Record<string, string | number>;
+  query?: Record<string, string | number | boolean | undefined | null>;
+  hash?: string;
+}
+type RouteLocation = string | RouteLocationRaw;
+declare function resolveRoute(to: RouteLocation, routeMap?: Record<string, {
+  path: string;
+  route: string;
+}>): string;
+type TypedLinkProps = {
+  to?: RouteLocation;
+  href?: string;
+  replace?: boolean;
+  prefetch?: boolean;
+  as?: string;
+  activeClass?: string;
+  exactActiveClass?: string;
+};
+declare function isActiveRoute(currentPath: string, targetHref: string, exact?: boolean): boolean;
+//#endregion
+//#region src/islands.d.ts
+interface DomElement {
+  getAttribute(name: string): string | null;
+  setAttribute(name: string, value: string): void;
+  hasAttribute(name: string): boolean;
+}
+interface NodeListOf<T> {
+  forEach(callback: (value: T, key: number, parent: NodeListOf<T>) => void): void;
+}
+interface DomParentNode {
+  querySelectorAll(selector: string): NodeListOf<DomElement>;
+}
+interface IslandHydrateOptions {
+  getComponent?: (name: string) => Component | Promise<Component> | null;
+  appContext?: App;
+  onHydrated?: (el: DomElement, component: Component) => void;
+}
+interface IslandRecord {
+  el: DomElement;
+  id: string;
+  componentName: string;
+  directive: string;
+  mediaQuery?: string;
+  props: Record<string, unknown>;
+}
+declare function collectIslands(root?: DomParentNode): IslandRecord[];
+declare function hydrateIsland(record: IslandRecord, component: Component, options?: IslandHydrateOptions): void;
+interface HydrateIslandsOptions extends IslandHydrateOptions {
+  root?: DomParentNode;
+  components?: Record<string, Component | (() => Promise<Component>)>;
+}
+declare function hydrateIslands(options?: HydrateIslandsOptions): void;
+//#endregion
+//#region src/i18n.d.ts
+interface VueI18nInstance {
+  locale: {
+    value: string;
+  };
+  fallbackLocale: string;
+  availableLocales: string[];
+  t: (key: string, params?: Record<string, string | number>) => string;
+  setLocale: (locale: string) => void;
+  getLocale: () => string;
+  onLocaleChange: (callback: LocaleChangeCallback) => () => void;
+  getLocaleDir: (locale?: string) => 'ltr' | 'rtl';
+  getLocaleName: (locale?: string) => string | undefined;
+  localeDir: {
+    value: 'ltr' | 'rtl';
+  };
+  localeName: {
+    value: string | undefined;
+  };
+}
+declare function useI18n(): VueI18nInstance;
+declare function defineLocale(definition: LocaleDefinition): LocaleDefinition;
+declare function t(key: string, params?: Record<string, string | number>): string;
+declare function setLocale(locale: string): void;
+declare function getLocale(): string;
+declare function onLocaleChange(callback: LocaleChangeCallback): () => void;
+declare function getLocaleDir(locale?: string): 'ltr' | 'rtl';
+declare function getLocaleName(locale?: string): string | undefined;
+declare function getRegisteredLocales(): string[];
+declare function detectLocale(acceptLanguage?: string): string;
+declare function detectBrowserLocale(): string;
+declare function addLocale(code: string, messages: LocaleMessages, options?: {
+  name?: string;
+  dir?: 'ltr' | 'rtl';
+}): void;
+declare function mergeLocale(code: string, messages: LocaleMessages): void;
+declare function clearLocales(): void;
+declare function getI18nConfig(): I18nConfig;
+declare function setI18nConfig(config: Partial<I18nConfig>): void;
+declare function localizePath(path: string, locale?: string): string;
+declare function switchLocalePath(newLocale: string, currentPath?: string): string;
+declare function getDefaultLocale(): string;
+declare function extractLocaleFromPath(path: string): {
+  locale: string | null;
+  pathWithoutLocale: string;
+};
+declare function useSwitchLocalePath(): import("vue").ComputedRef<(newLocale: string) => any>;
+declare function useLocalePath(): import("vue").ComputedRef<(path: string, locale?: string) => any>;
+//#endregion
+//#region src/index.d.ts
+declare module 'vue-router' {
+  interface RouteMeta {
+    /** Whether this page is kept-alive (set by `definePage({ cache: true })`). */
+    cache?: boolean;
+    /** The page route name (set by ubean's virtual pages module). */
+    pageName?: string;
+    /** The layout name to use, or `false` to disable layout. */
+    layout?: string | false;
+    /** Whether authentication is required for this route. */
+    requiresAuth?: boolean;
+    /**
+     * Page transition name (used by `<PageView>`). Falls back to the global
+     * `usePageTransition()` ref when not set. Set to empty string to disable
+     * transitions for this specific page.
+     */
+    transition?: string;
+  }
+}
+//#endregion
+export { type AppPluginConfig, type CreateUbeanRouterOptions, type DataCacheStore, type DefineAppOptions, Head, type VueHeadClient as HeadClient, type HydrateIslandsOptions, type IslandHydrateOptions, type IslandRecord, Link, type LinkProps, type LinkTag, type MetaTag, PageView, type ResolvedAppConfig, type RouteLocation, type RouteLocationRaw, type SeoMetadata, type TypedLinkProps, type UbeanAppInstance, type UbeanAppOptions, type UbeanVueContext, type UseAsyncDataOptions, type UseAsyncDataReturn, type UseCacheViewsReturn, type UsePageTransitionReturn, type UseReloadSignalReturn, type ViewTransitionOptions, type VueHeadClient$1 as VueHeadClient, type VueI18nInstance, addLocale, applyAppConfig, clearCache, clearLocales, clearPageTransition, collectIslands, createClientHead, createDataCacheStore, createDefaultAppConfig, createLinkHandler, createServerHead, createUbeanApp, createUbeanRouter, createUbeanSSRApp, createUseAsyncData, defineApp, defineDataKey, defineLocale, defineMeta, defineMiddleware, definePage, detectBrowserLocale, detectLocale, disablePageCache, enablePageCache, excludePageCache, extractLocaleFromPath, extractPageData, getCacheEnabled, getCachedViewNames, getDefaultLocale, getExcludedViewNames, getI18nConfig, getInitialPageData, getInvalidatedKeysForAction, getLocale, getLocaleDir, getLocaleName, getNavigationType, getPageTransitionName, getRegisteredLocales, getReloadCounter, hydrateIsland, hydrateIslands, includePageCache, initCachedViewsFromRoutes, injectHead, invalidateCache, invalidatePageCache, isActiveRoute, isCacheEnabled, isPageCached, isPageExcluded, isReloading, localizePath, mergeLocale, onLocaleChange, reloadPage, resetRouteCache, resolveRoute, setI18nConfig, setLocale, setPageTransition, supportsViewTransitions, switchLocalePath, t, useCacheViews, useUnheadHead as useHead, useHeadInstance, useI18n, useLocalePath, usePage, usePageTransition, useReloadSignal, useRouter, useSeoMeta, useServerData, useSwitchLocalePath, useViewTransition, useViewTransitionState, withViewTransition };