@wow-two-beta/ui-vue 0.0.2

package/dist/query/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","sources":["../../src/query/QueryTestUtils.ts"],"sourcesContent":["import { createApp, defineComponent, type App, type Component } from 'vue';\nimport { QueryClient } from '@tanstack/vue-query';\nimport { mount, type ComponentMountingOptions, type GlobalMountOptions, type VueWrapper } from '@vue/test-utils';\n\nimport { queryPlugin } from './QueryPlugin';\n\nconst GcTimeMs = Infinity;\n\n/** Creates a `QueryClient` tuned for tests — retries off, no gc eviction, no focus-refetch. */\nexport function createTestQueryClient(): QueryClient {\n  return new QueryClient({\n    defaultOptions: {\n      queries: { retry: false, gcTime: GcTimeMs, refetchOnWindowFocus: false },\n      mutations: { retry: false },\n    },\n  });\n}\n\n/** Defines options for `mountWithQuery` — `@vue/test-utils` mounting options plus the client to provide. */\nexport type MountWithQueryOptions<T> = ComponentMountingOptions<T> & {\n  /** The client to provide; a fresh test client when omitted. */\n  readonly client?: QueryClient;\n};\n\n/** Represents the `@vue/test-utils` wrapper augmented with the `QueryClient` it was mounted against. */\nexport type MountWithQueryResult = VueWrapper & { readonly client: QueryClient };\n\n/**\n * Mounts `component` with a query client provided, for tests — returns the `@vue/test-utils` wrapper\n * plus the client used.\n *\n * `@testing-library/react` has no Vue counterpart in this repo; `@vue/test-utils` is the installed\n * equivalent, and it MOUNTS A COMPONENT rather than rendering an already-created element, which is\n * why this takes `(component, { props, slots, … })` where React took `(ui)`.\n */\nexport function mountWithQuery<T>(\n  component: T,\n  options: MountWithQueryOptions<T> = {} as MountWithQueryOptions<T>,\n): MountWithQueryResult {\n  const { client = createTestQueryClient(), ...rest } = options;\n  const globalOptions: GlobalMountOptions = (rest as { global?: GlobalMountOptions }).global ?? {};\n\n  const wrapper = mount(component as never, {\n    ...(rest as object),\n    global: { ...globalOptions, plugins: [...(globalOptions.plugins ?? []), queryPlugin(client)] },\n  }) as VueWrapper;\n\n  return Object.assign(wrapper, { client });\n}\n\n/** @deprecated The React name for {@link mountWithQuery} — kept so a ported test compiles; the signature is the Vue one (component + mounting options). */\nexport const renderWithQuery = mountWithQuery;\n\n/**\n * Builds the `@vue/test-utils` mounting options that provide a query client — spread into a `mount`\n * call: `mount(Component, createQueryWrapper(client))`.\n *\n * React returned a WRAPPER COMPONENT for `renderHook(fn, { wrapper })`. `@vue/test-utils` has no\n * `renderHook`, and providing a client is a mount option here rather than a wrapping component, so\n * that is the shape. For a composable with no component at all, reach for `runWithQuery`.\n */\nexport function createQueryWrapper(client: QueryClient = createTestQueryClient()): {\n  global: GlobalMountOptions;\n} {\n  return { global: { plugins: [queryPlugin(client)] } };\n}\n\n/** Represents a composable run under a query client — its return value plus the teardown. */\nexport interface RunWithQueryResult<T> {\n  /** Whatever the composable returned. */\n  readonly result: T;\n\n  /** The client it ran against. */\n  readonly client: QueryClient;\n\n  /** The host app, for `app.config` tweaks. */\n  readonly app: App;\n\n  /** Tears the host app down — runs `onScopeDispose` / `onUnmounted` cleanups. */\n  readonly unmount: () => void;\n}\n\n/**\n * Runs a composable inside a throwaway app with a query client provided — the counterpart of React's\n * `renderHook` + wrapper, which `@vue/test-utils` does not ship.\n *\n * Mounts a renderless host into a detached element, so it needs a DOM environment.\n */\nexport function runWithQuery<T>(\n  composable: () => T,\n  client: QueryClient = createTestQueryClient(),\n): RunWithQueryResult<T> {\n  let result!: T;\n\n  const host: Component = defineComponent({\n    name: 'QueryComposableHost',\n    setup() {\n      result = composable();\n      return () => null;\n    },\n  });\n\n  const app = createApp(host);\n  app.use(queryPlugin(client));\n  app.mount(document.createElement('div'));\n\n  return { result, client, app, unmount: () => app.unmount() };\n}\n"],"names":[],"mappings":";;;;AAMA,MAAM,WAAW;AAGV,SAAS,wBAAqC;AACnD,SAAO,IAAI,YAAY;AAAA,IACrB,gBAAgB;AAAA,MACd,SAAS,EAAE,OAAO,OAAO,QAAQ,UAAU,sBAAsB,MAAA;AAAA,MACjE,WAAW,EAAE,OAAO,MAAA;AAAA,IAAM;AAAA,EAC5B,CACD;AACH;AAmBO,SAAS,eACd,WACA,UAAoC,IACd;AACtB,QAAM,EAAE,SAAS,sBAAA,GAAyB,GAAG,SAAS;AACtD,QAAM,gBAAqC,KAAyC,UAAU,CAAA;AAE9F,QAAM,UAAU,MAAM,WAAoB;AAAA,IACxC,GAAI;AAAA,IACJ,QAAQ,EAAE,GAAG,eAAe,SAAS,CAAC,GAAI,cAAc,WAAW,CAAA,GAAK,YAAY,MAAM,CAAC,EAAA;AAAA,EAAE,CAC9F;AAED,SAAO,OAAO,OAAO,SAAS,EAAE,QAAQ;AAC1C;AAGO,MAAM,kBAAkB;AAUxB,SAAS,mBAAmB,SAAsB,yBAEvD;AACA,SAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,YAAY,MAAM,CAAC,IAAE;AACpD;AAuBO,SAAS,aACd,YACA,SAAsB,yBACC;AACvB,MAAI;AAEJ,QAAM,OAAkB,gBAAgB;AAAA,IACtC,MAAM;AAAA,IACN,QAAQ;AACN,eAAS,WAAA;AACT,aAAO,MAAM;AAAA,IACf;AAAA,EAAA,CACD;AAED,QAAM,MAAM,UAAU,IAAI;AAC1B,MAAI,IAAI,YAAY,MAAM,CAAC;AAC3B,MAAI,MAAM,SAAS,cAAc,KAAK,CAAC;AAEvC,SAAO,EAAE,QAAQ,QAAQ,KAAK,SAAS,MAAM,IAAI,UAAQ;AAC3D;"}

package/dist/router/AppErrorBoundary.vue.d.ts

@@ -0,0 +1,26 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the props for {@link AppErrorBoundary}. */
+export interface AppErrorBoundaryProps {
+    /** The path the "back to start" link points at. Default `/`. */
+    homePath?: string;
+    /** Whether to clear the caught error on the next successful navigation. Default `true`. */
+    resetOnNavigate?: boolean;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<AppErrorBoundaryProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AppErrorBoundaryProps> & Readonly<{}>, {
+    homePath: string;
+    resetOnNavigate: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    /** The guarded subtree — normally `<RouterView />`. */
+    default(): unknown;
+    /** Replaces the built-in fallback; receives the caught error and a reset callback. */
+    fallback?(props: {
+        error: unknown;
+        reset: () => void;
+    }): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/router/AppNavLink.vue.d.ts

@@ -0,0 +1,40 @@
+import { RouteLocationRaw } from 'vue-router';
+import { LazyRoute } from './RouteConfig';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * Defines the props for {@link AppNavLink}.
+ *
+ * `aria-current` is NOT declared — a hyphenated prop would arrive as `props.ariaCurrent` and stop
+ * being an attribute. `NavItem` sets `aria-current="page"` off the resolved active state instead.
+ */
+export interface AppNavLinkProps {
+    /** The destination. React took a bare path; a full `RouteLocationRaw` (named route, params, query) is accepted here. */
+    to: RouteLocationRaw;
+    /** Whether to match the destination exactly (no descendant paths) for the active state. */
+    end?: boolean;
+    /** Whether to replace the current history entry instead of pushing. */
+    replace?: boolean;
+    /** Whether to animate this navigation with the View Transitions API. */
+    viewTransition?: boolean;
+    /** The destination's lazy module — warmed on hover / focus (intent prefetch). */
+    prefetch?: LazyRoute;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<AppNavLinkProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AppNavLinkProps> & Readonly<{}>, {
+    replace: boolean;
+    end: boolean;
+    viewTransition: boolean;
+    prefetch: LazyRoute;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    /** The link label — React's `children`. */
+    default(): unknown;
+    /** The leading icon. React's `icon` prop. */
+    icon?(): unknown;
+    /** The trailing slot — typically a count badge or status dot. */
+    trailing?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/router/CreateAppRouter.d.ts

@@ -0,0 +1,65 @@
+import { Component } from 'vue';
+import { Router } from 'vue-router';
+import { PageView } from './PageViewTracker';
+import { RouteConfig } from './RouteConfig';
+import { RoutePersistenceOptions } from './RoutePersistence';
+/**
+ * Defines the history strategy the router uses.
+ *
+ * Named `RouterHistoryMode`, not React's `RouterHistory`: vue-router exports a `RouterHistory` TYPE
+ * for the history object itself, and one name for two things in the same import graph is a trap.
+ * `RouterHistory` stays exported as an alias so React-era call sites keep compiling.
+ */
+export declare const RouterHistoryMode: {
+    /** Refers to the HTML5 History API — clean URLs (default). */
+    readonly Browser: "browser";
+    /** Refers to hash-based history — static hosting / file protocol. */
+    readonly Hash: "hash";
+    /** Refers to in-memory history — SSR and tests; no URL bar involvement. */
+    readonly Memory: "memory";
+};
+export type RouterHistoryMode = (typeof RouterHistoryMode)[keyof typeof RouterHistoryMode];
+/** @deprecated The React name for {@link RouterHistoryMode} — collides with vue-router's own `RouterHistory` type. */
+export declare const RouterHistory: {
+    /** Refers to the HTML5 History API — clean URLs (default). */
+    readonly Browser: "browser";
+    /** Refers to hash-based history — static hosting / file protocol. */
+    readonly Hash: "hash";
+    /** Refers to in-memory history — SSR and tests; no URL bar involvement. */
+    readonly Memory: "memory";
+};
+/** @deprecated The React name for {@link RouterHistoryMode} — collides with vue-router's own `RouterHistory` type. */
+export type RouterHistory = RouterHistoryMode;
+/** Options for `createAppRouter` — every field defaults sensibly; apps usually pass none. */
+export interface CreateAppRouterOptions {
+    /** A leading path prefix for every route — vue-router's history `base`. */
+    readonly basename?: string;
+    /** Overrides the built-in `*` catch-all page. */
+    readonly notFound?: Component;
+    /** Whether to restore scroll position across navigations. Default `true`. */
+    readonly scrollRestoration?: boolean;
+    /** The document-title suffix (usually the app name) applied on every navigation. */
+    readonly titleSuffix?: string;
+    /** The history strategy. Default `RouterHistoryMode.Browser` — and always memory history without a `window`. */
+    readonly history?: RouterHistoryMode;
+    /** Emits a page-view on each navigation — an analytics sink; when set, installs a page-view tracker. */
+    readonly onPageView?: (view: PageView) => void;
+    /** Route persistence settings, or `false` to install none. Default: installed with its own defaults (persist on, restore off). */
+    readonly routePersistence?: RoutePersistenceOptions | false;
+}
+/**
+ * Builds the app's router from a declarative `RouteConfig`. The app declares its routes; this wrapper
+ * owns the vue-router machinery — scroll behavior, the catch-all, and the root-mounted behaviors
+ * (title · meta tags · route persistence · page views) that React composed inside an `<AppRoot>`
+ * layout route. vue-router installs as a plugin and has no root element, so those behaviors are
+ * router hooks registered here instead; each is separately exported as an `install*` function.
+ *
+ * It is the single extension point: cross-cutting routing behavior is added here, every consumer
+ * inherits it.
+ *
+ * ```ts
+ * const router = createAppRouter(routes, { titleSuffix: 'Acme' });
+ * createApp(App).use(router).mount('#app');
+ * ```
+ */
+export declare function createAppRouter(config: RouteConfig, options?: CreateAppRouterOptions): Router;

package/dist/router/DocumentMeta.d.ts

@@ -0,0 +1,9 @@
+import { Router } from 'vue-router';
+/**
+ * Syncs document `<meta>` tags to the deepest matched route's `handle.meta` (description + arbitrary
+ * name keys). Returns the unregister function.
+ *
+ * React's null-rendering `<DocumentMeta>` becomes an `afterEach` hook, for the same reason
+ * `installDocumentTitle` does; `createAppRouter` wires it for you. No-op without a `document` (SSR).
+ */
+export declare function installDocumentMeta(router: Router): () => void;

package/dist/router/DocumentTitle.d.ts

@@ -0,0 +1,18 @@
+import { Router } from 'vue-router';
+/** Defines options for `installDocumentTitle`. */
+export interface DocumentTitleOptions {
+    /** The suffix appended after the route title — usually the app name. */
+    readonly suffix?: string;
+}
+/**
+ * Syncs `document.title` to the deepest matched route's `handle.title`, plus an optional app suffix.
+ * Returns the unregister function.
+ *
+ * React shipped this as a null-rendering `<DocumentTitle>` the router root mounted; vue-router has no
+ * root element, and "run on every navigation" is `afterEach`. `createAppRouter({ titleSuffix })` wires
+ * it for you — call this directly only to re-wire it with a different suffix.
+ *
+ * No-op without a `document` (SSR): `afterEach` DOES run on the server during `router.push`, so the
+ * guard is the difference between a rendered page and a `ReferenceError`.
+ */
+export declare function installDocumentTitle(router: Router, options?: DocumentTitleOptions): () => void;

package/dist/router/Guards.d.ts

@@ -0,0 +1,29 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+import { LocationQuery } from 'vue-router';
+import { RouteGuard } from './RouteConfig';
+/** The shapes `resolveReturnTo` reads a `returnTo` out of — a query string, parsed params, or vue-router's `route.query`. */
+export type ReturnToSource = URLSearchParams | string | LocationQuery;
+/**
+ * Builds a route guard that allows activation when authenticated, else redirects to `loginPath`
+ * with the attempted path+search captured as a `returnTo` query param for post-login restore.
+ *
+ * Takes an `isAuthenticated` callback so the check stays app-owned — pass a stub today, swap the
+ * real one in later without touching any route.
+ *
+ * @example
+ * const isAuthenticated = () => Boolean(localStorage.getItem('token'));
+ * // { path: '/library', guard: requireAuth(isAuthenticated), lazy: … }
+ */
+export declare function requireAuth(isAuthenticated: () => boolean | Promise<boolean>, loginPath?: string): RouteGuard;
+/** Builds a login redirect (`{loginPath}?returnTo=…`) encoding the attempted path+search — accepts a full URL or a root-relative `fullPath`. */
+export declare function buildReturnTo(loginPath: string, from: string): string;
+/** Resolves the safe same-origin return path from a `returnTo` param, rejecting open-redirect targets → `fallback`. */
+export declare function resolveReturnTo(search: ReturnToSource, fallback?: string): string;
+/**
+ * Provides access to the safe post-login return path read from the current URL's `returnTo` param.
+ *
+ * Returns a `ComputedRef`, not a bare string — the value has to track `route.query`.
+ */
+export declare function useReturnTo(fallback?: MaybeRefOrGetter<string>): ComputedRef<string>;
+/** @internal Reports whether a target is a same-origin root-relative path (open-redirect guard) — shared by `returnTo` resolution and route restore; not part of the public surface. */
+export declare function isSafeInternalPath(target: string): boolean;

package/dist/router/LazyRoute.d.ts

@@ -0,0 +1,16 @@
+import { Component } from 'vue';
+import { LazyRoute } from './RouteConfig';
+/** Forces a full reload to fetch the current deploy's chunk manifest — a last resort for a persistent chunk-load failure. No-op without a `window` (SSR). */
+export declare function reloadOnChunkError(): void;
+/**
+ * Wraps a code-split importer so a transient chunk-load failure — typically a stale deploy whose
+ * hashed chunk no longer exists after a redeploy — retries once after a short delay before
+ * rejecting. A persistent failure rejects so the router's error handling catches it. Stays
+ * type-compatible with `LazyRoute`.
+ */
+export declare function lazyRoute(importer: LazyRoute): LazyRoute;
+/**
+ * @internal Normalizes a `default | Component` lazy module into the single component vue-router's
+ * async `component` loader expects.
+ */
+export declare function toAsyncComponent(lazy: LazyRoute): () => Promise<Component>;

package/dist/router/NavigationProgress.vue.d.ts

@@ -0,0 +1,19 @@
+import { NavigationProgressMode, NavigationProgressVariant } from './NavigationProgressModes';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * Defines the props for {@link NavigationProgress}.
+ *
+ * `aria-label` is NOT declared: a hyphenated prop arrives as `props.ariaLabel` and stops being an
+ * attribute, so it stays a fallthrough attr, read off `useAttrs()` and defaulted to `Loading`.
+ */
+export interface NavigationProgressProps {
+    /** The visual form — a slim top bar (default) or a pulsing heartbeat. */
+    variant?: NavigationProgressVariant;
+    /** The busy sources that toggle visibility — route (default), manual (backend), or both. */
+    mode?: NavigationProgressMode;
+}
+declare const _default: DefineComponent<NavigationProgressProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<NavigationProgressProps> & Readonly<{}>, {
+    variant: NavigationProgressVariant;
+    mode: NavigationProgressMode;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/router/NavigationProgressModes.d.ts

@@ -0,0 +1,18 @@
+/** Defines the visual form of the navigation indicator — a slim top bar or a pulsing heartbeat. */
+export declare const NavigationProgressVariant: {
+    /** Refers to a slim indeterminate top bar. */
+    readonly Bar: "bar";
+    /** Refers to a pulsing heartbeat dot. */
+    readonly Heartbeat: "heartbeat";
+};
+export type NavigationProgressVariant = (typeof NavigationProgressVariant)[keyof typeof NavigationProgressVariant];
+/** Defines which busy sources drive the indicator — route navigation, manual spans, or both. */
+export declare const NavigationProgressMode: {
+    /** Refers to route-navigation busy state (vue-router). */
+    readonly Auto: "auto";
+    /** Refers to manual / backend busy spans. */
+    readonly Manual: "manual";
+    /** Refers to either busy source. */
+    readonly Both: "both";
+};
+export type NavigationProgressMode = (typeof NavigationProgressMode)[keyof typeof NavigationProgressMode];

package/dist/router/NotFound.vue.d.ts

@@ -0,0 +1,10 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the props for {@link NotFound}. */
+export interface NotFoundProps {
+    /** The path the "back to start" link points at. Default `/`. */
+    homePath?: string;
+}
+declare const _default: DefineComponent<NotFoundProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<NotFoundProps> & Readonly<{}>, {
+    homePath: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/router/PageViewTracker.d.ts

@@ -0,0 +1,23 @@
+import { Router } from 'vue-router';
+/** Represents a single page-view event — the resolved pathname and the deepest matched route title. */
+export interface PageView {
+    /** The pathname navigated to. */
+    readonly pathname: string;
+    /** The deepest matched route's `handle.title`, when one is set. */
+    readonly title?: string;
+}
+/** Defines options for `installPageViewTracker`. */
+export interface PageViewTrackerOptions {
+    /** Emits a page-view on the initial navigation and on each subsequent one. */
+    readonly onPageView: (view: PageView) => void;
+}
+/**
+ * Emits a page-view (pathname + matched `handle.title`) on every completed navigation. Returns the
+ * unregister function.
+ *
+ * React's null-rendering `<PageViewTracker>` becomes an `afterEach` hook. It also needed a
+ * `location.key` guard against StrictMode's double-invoked effect and against revalidations; neither
+ * exists here — `afterEach` fires exactly once per settled navigation. A navigation that failed
+ * (aborted / redirected away / cancelled) is skipped, so only pages actually shown are reported.
+ */
+export declare function installPageViewTracker(router: Router, options: PageViewTrackerOptions): () => void;

package/dist/router/Paths.d.ts

@@ -0,0 +1,18 @@
+/** Defines the union of `:param` names inferred from a route template literal (`never` when it has none). */
+export type PathParamName<Template extends string> = Template extends `${string}:${infer Param}/${infer Rest}` ? Param | PathParamName<Rest> : Template extends `${string}:${infer Param}` ? Param : never;
+/** Defines the params object a route template requires — one required string key per `:segment`. */
+export type PathParams<Template extends string> = {
+    readonly [Key in PathParamName<Template>]: string;
+};
+/** Defines a path builder's argument tuple — empty when the template declares no `:params`, else one required params object. */
+export type PathBuilderArgs<Template extends string> = [
+    PathParamName<Template>
+] extends [never] ? [] : [params: PathParams<Template>];
+/** Defines a typed path builder — call with the template's params for the concrete href; `.pattern` is the route-table template. */
+export interface PathBuilder<Template extends string> {
+    (...args: PathBuilderArgs<Template>): string;
+    /** The route pattern template (e.g. `/projects/:id`) — used as the route table's `path`. */
+    readonly pattern: Template;
+}
+/** Creates a typed path builder from a route template — substitutes + URL-encodes each `:param`, and carries the template as `.pattern`. */
+export declare function definePath<const Template extends string>(template: Template): PathBuilder<Template>;

package/dist/router/ProgressProvider.vue.d.ts

@@ -0,0 +1,19 @@
+import { NavigationProgressState } from './UseNavigationProgress';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the props for {@link ProgressProvider}. */
+export interface ProgressProviderProps {
+    /** An externally created state to provide (from `createNavigationProgress()`); a fresh one when omitted. */
+    state?: NavigationProgressState;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<ProgressProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ProgressProviderProps> & Readonly<{}>, {
+    state: NavigationProgressState;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    /** The subtree that can drive and observe the shared manual busy state. */
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/router/RouteAnnouncer.vue.d.ts

@@ -0,0 +1,10 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the props for {@link RouteAnnouncer}. */
+export interface RouteAnnouncerProps {
+    /** Whether to skip the focus reset and announcement on the very first mount. Default `true`. */
+    skipInitial?: boolean;
+}
+declare const _default: DefineComponent<RouteAnnouncerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RouteAnnouncerProps> & Readonly<{}>, {
+    skipInitial: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/router/RouteConfig.d.ts

@@ -0,0 +1,82 @@
+import { Component, VNode } from 'vue';
+import { RouteLocationNormalized, RouteLocationRaw, RouteParamsGeneric } from 'vue-router';
+/** Defines a breadcrumb label — the Vue counterpart of React's `ReactNode` crumb (mirrors `feedback`'s `NoticeNode`). */
+export type CrumbNode = string | VNode;
+/** Defines per-route meta tags surfaced to the document head (read off the deepest match's `meta.meta`). */
+export interface RouteMeta {
+    /** The meta description for this route. */
+    readonly description?: string;
+    readonly [key: string]: string | undefined;
+}
+/** Defines the outcome of a route guard — `true` to allow activation, or a location to redirect to. */
+export type GuardResult = true | {
+    readonly redirect: RouteLocationRaw;
+};
+/**
+ * Defines the context a route guard receives.
+ *
+ * React's guards ran inside a react-router loader and read a `Request`; vue-router guards run as
+ * `beforeEnter` and receive the two normalized locations instead. `params` is `to.params`, kept
+ * under React's name because guards read it constantly.
+ */
+export interface GuardContext {
+    /** The location being navigated to. */
+    readonly to: RouteLocationNormalized;
+    /** The location being navigated from. */
+    readonly from: RouteLocationNormalized;
+    /** The matched path params — the same object as `to.params`. */
+    readonly params: RouteParamsGeneric;
+}
+/** Defines a route guard — runs before the route activates; returns allow (`true`) or a redirect. */
+export type RouteGuard = (context: GuardContext) => GuardResult | Promise<GuardResult>;
+/**
+ * Defines per-route metadata surfaced to breadcrumbs / title / analytics — app keys pass through
+ * untouched. Compiles into the route record's native vue-router `meta`, so `route.meta.title`
+ * reads it without any helper.
+ */
+export interface RouteHandle {
+    /** The breadcrumb label for this route. */
+    readonly crumb?: CrumbNode;
+    /** The document title for this route. */
+    readonly title?: string;
+    /** The per-route meta tags (description / og) surfaced to the document head. */
+    readonly meta?: RouteMeta;
+    readonly [key: string]: unknown;
+}
+/** Defines a code-split route module — resolves to a `default` or a named `Component` export. */
+export type LazyRoute = () => Promise<{
+    default: Component;
+} | {
+    Component: Component;
+}>;
+/**
+ * Defines the declarative route unit an app authors — a curated subset of vue-router's
+ * `RouteRecordRaw`. `createAppRouter` compiles it: guards become `beforeEnter`, `handle` becomes
+ * `meta`, `id` becomes `name`, and the `*` catch-all is appended for you.
+ */
+export interface AppRoute {
+    /** The path segment, relative to the parent. Omit for a pathless layout route. */
+    readonly path?: string;
+    /** Renders in the parent's `<RouterView>` at the parent's path — compiles to a child with `path: ''`. Mutually exclusive with `path`. */
+    readonly index?: boolean;
+    /** The eager component. Use `lazy` to code-split instead. React's `element` (a `ReactNode`) has no Vue counterpart — a component is the unit here. */
+    readonly component?: Component;
+    /** A `*Layout` rendering a `<RouterView>`; an alias of `component`, kept for the React authoring shape. */
+    readonly layout?: Component;
+    /** A code-split module for this route — preferred for pages. */
+    readonly lazy?: LazyRoute;
+    /** Redirect this route to another location. Combined with `guard`, the guards run first (React's ordering). */
+    readonly redirect?: RouteLocationRaw;
+    /** A guard (or chain) run before activation — compiles to the record's `beforeEnter`. */
+    readonly guard?: RouteGuard | readonly RouteGuard[];
+    /** Per-route metadata (crumb / title / meta / app keys) — compiles to the record's `meta`. */
+    readonly handle?: RouteHandle;
+    /** A route-scoped error component; `AppErrorBoundary` renders it instead of its own fallback when this route is matched. */
+    readonly errorComponent?: Component;
+    /** Nested child routes. */
+    readonly children?: readonly AppRoute[];
+    /** A stable id — compiles to the record's `name`, vue-router's stable identity. */
+    readonly id?: string;
+}
+/** Defines the full route tree an app passes to `createAppRouter`. */
+export type RouteConfig = readonly AppRoute[];

package/dist/router/RouteHandles.d.ts

@@ -0,0 +1,24 @@
+import { RouteParamsGeneric } from 'vue-router';
+import { RouteHandle } from './RouteConfig';
+/**
+ * The only part of a route location these readers need. Structural on purpose: `afterEach` hands
+ * out a `RouteLocationNormalized` while `useRoute()` hands out a `RouteLocationNormalizedLoaded`,
+ * and both satisfy this.
+ */
+export interface MatchedRoute {
+    readonly matched: readonly {
+        readonly meta: unknown;
+    }[];
+}
+/** A matched record's `meta`, read back as the `RouteHandle` it was authored as. */
+export declare function toHandle(meta: unknown): RouteHandle | undefined;
+/** Reads the deepest matched route's handle value — the innermost match wins, exactly as React's reversed `useMatches()` scan did. */
+export declare function deepestHandleValue<TValue>(route: MatchedRoute, read: (handle: RouteHandle) => TValue | undefined): TValue | undefined;
+/**
+ * Resolves a matched record's path PATTERN against the active params — `/projects/:id` → `/projects/7`.
+ *
+ * vue-router absolutizes a child record's `path` when the tree is built, so a matched record already
+ * carries its full pattern; only the params still need substituting. React got the resolved pathname
+ * for free on each `useMatches()` entry.
+ */
+export declare function resolveMatchedPath(pattern: string, params: RouteParamsGeneric): string;

package/dist/router/RoutePersistence.d.ts

@@ -0,0 +1,21 @@
+import { Router } from 'vue-router';
+/** Defines options for `installRoutePersistence`. */
+export interface RoutePersistenceOptions {
+    /** The localStorage key the current route is stored under. */
+    readonly storageKey?: string;
+    /** Whether to redirect to the saved route on the first navigation when the app opened at its root. */
+    readonly restore?: boolean;
+}
+/**
+ * Persists the current route to localStorage on each navigation and, when `restore` is set, sends
+ * the first navigation back to the saved route if the app opened at its root. Returns the unregister
+ * function.
+ *
+ * React's null-rendering `<RoutePersistence>` becomes a hook pair. The restore is a `beforeEach`
+ * REDIRECT rather than React's mount-effect `navigate(…, { replace: true })` — it lands before the
+ * root route ever renders, so there is no flash of the wrong page and no history entry to replace.
+ *
+ * No-op without a `window` (SSR), and every storage touch is wrapped: `localStorage` throws in
+ * private mode and at quota.
+ */
+export declare function installRoutePersistence(router: Router, options?: RoutePersistenceOptions): () => void;

package/dist/router/UseBreadcrumbs.d.ts

@@ -0,0 +1,17 @@
+import { ComputedRef } from 'vue';
+import { CrumbNode } from './RouteConfig';
+/** Represents one breadcrumb derived from a matched route's `handle.crumb`. */
+export interface Breadcrumb {
+    /** The breadcrumb label to render. */
+    readonly crumb: CrumbNode;
+    /** The matched route's resolved pathname — the crumb's link target. */
+    readonly pathname: string;
+    /** The matched route's stable identity — its `id` (vue-router `name`), else its path pattern. */
+    readonly id: string;
+}
+/**
+ * Manages the ordered breadcrumb trail derived from the active route matches whose `handle.crumb` is set.
+ *
+ * Returns a `ComputedRef`, not a bare array — the trail has to track the active route.
+ */
+export declare function useBreadcrumbs(): ComputedRef<readonly Breadcrumb[]>;

package/dist/router/UseNavigationBlocker.d.ts

@@ -0,0 +1,41 @@
+import { MaybeRefOrGetter } from 'vue';
+import { RouteLocationNormalized } from 'vue-router';
+/** Defines the blocker's phase — react-router's `Blocker.state` vocabulary, kept verbatim. */
+export declare const BlockerState: {
+    /** Refers to no navigation being held. */
+    readonly Unblocked: "unblocked";
+    /** Refers to a navigation held pending a decision — render the confirm dialog. */
+    readonly Blocked: "blocked";
+    /** Refers to a released navigation currently running. */
+    readonly Proceeding: "proceeding";
+};
+export type BlockerState = (typeof BlockerState)[keyof typeof BlockerState];
+/**
+ * Defines the blocker handle a confirm dialog drives — react-router's `Blocker` shape reimplemented
+ * over a vue-router global guard.
+ *
+ * `state` and `location` are REACTIVE PROPERTIES (native getters over refs, the house convention);
+ * read them off the object rather than destructuring.
+ */
+export interface NavigationBlocker {
+    /** The current phase. */
+    readonly state: BlockerState;
+    /** The held navigation's target, or `null` when nothing is held. */
+    readonly location: RouteLocationNormalized | null;
+    /** Releases the held navigation — runs it without re-blocking. */
+    readonly proceed: () => void;
+    /** Discards the held navigation and returns to `unblocked`. */
+    readonly reset: () => void;
+}
+/**
+ * Manages navigation blocking for a dirty form — intercepts in-app routing and full-page unloads
+ * while `shouldBlock`, and hands back the blocker a confirm dialog drives.
+ *
+ * react-router shipped `useBlocker`; vue-router has only `onBeforeRouteLeave`, which fires solely for
+ * the component's OWN route and cannot hold a navigation for a later decision. This reimplements the
+ * blocker over a global `beforeEach`: a blocked navigation is aborted and its target parked, then
+ * `proceed()` re-pushes it with the guard stood down for exactly one navigation.
+ *
+ * The guard is torn down with the owning effect scope, so an unmounted form stops blocking.
+ */
+export declare function useNavigationBlocker(shouldBlock: MaybeRefOrGetter<boolean>): NavigationBlocker;

package/dist/router/UseNavigationProgress.d.ts

@@ -0,0 +1,32 @@
+import { InjectionKey } from 'vue';
+/**
+ * Defines the navigation-progress controls plus the ref-counted manual busy flag exposed to app code.
+ *
+ * `isBusy` is a REACTIVE PROPERTY — a native getter over the internal ref, the same shape `auth`'s
+ * `AuthApi` uses. Read it in a template, a `computed`, or a `watch` and it re-evaluates; destructuring
+ * (`const { isBusy } = useNavigationProgress()`) takes a one-time copy and will not update.
+ */
+export interface NavigationProgressState {
+    /** The ref-counted busy flag — true while at least one manual span is in flight. */
+    readonly isBusy: boolean;
+    /** Starts a manual busy span; returns an idempotent function that ends only that span. */
+    readonly begin: () => () => void;
+    /** Ends one manual busy span — the raw counterpart to `begin`, clamped at zero. */
+    readonly end: () => void;
+    /** Tracks a promise as a manual busy span — begins now, ends when it settles; resolves with the promise's value. */
+    readonly track: <T>(promise: Promise<T>) => Promise<T>;
+}
+/** The injection key backing `ProgressProvider` — React's `createContext(null)` counterpart. */
+export declare const NavigationProgressKey: InjectionKey<NavigationProgressState>;
+/**
+ * Creates a standalone navigation-progress state — ref-counts manual busy spans. Headless and
+ * component-free, so a plain module (a store, a test) can drive the indicator without mounting a
+ * provider. `ProgressProvider` is this factory plus a `provide`.
+ */
+export declare function createNavigationProgress(): NavigationProgressState;
+/** Provides a navigation-progress state to the current component's subtree; returns the state it provided. */
+export declare function provideNavigationProgress(state?: NavigationProgressState): NavigationProgressState;
+/** @internal Reads the navigation-progress state, or null when used outside a `ProgressProvider`. */
+export declare function useOptionalNavigationProgress(): NavigationProgressState | null;
+/** Provides access to the navigation-progress controls (begin / end / track) from the nearest `ProgressProvider`. */
+export declare function useNavigationProgress(): NavigationProgressState;

package/dist/router/UsePrefetch.d.ts

@@ -0,0 +1,19 @@
+import { LazyRoute } from './RouteConfig';
+/** Fires a lazy route's dynamic import once to warm its chunk; repeat calls for the same importer are ignored. */
+export declare function prefetch(importer: LazyRoute): void;
+/**
+ * Defines the hover/focus listeners to `v-bind` onto a `<RouterLink>` for intent prefetch.
+ *
+ * `onMouseenter`, not React's `onMouseEnter`: Vue derives the DOM event name with `hyphenate()`, so
+ * a camel-humped `onMouseEnter` key would bind a `mouse-enter` event that never fires.
+ */
+export interface PrefetchProps {
+    /** Warms the target chunk when the pointer enters the link. */
+    readonly onMouseenter: () => void;
+    /** Warms the target chunk when the link gains focus. */
+    readonly onFocus: () => void;
+}
+/** Builds hover/focus listeners that prefetch a lazy route's chunk on intent — `v-bind` onto a `<RouterLink>`. */
+export declare function prefetchProps(importer: LazyRoute): PrefetchProps;
+/** Manages intent-based prefetch — returns a `prefetch(importer)` that warms a lazy chunk exactly once. */
+export declare function usePrefetch(): (importer: LazyRoute) => void;

package/dist/router/UseRouteNavigating.d.ts

@@ -0,0 +1,15 @@
+import { ComputedRef, ShallowRef } from 'vue';
+import { Router } from 'vue-router';
+/**
+ * @internal Installs (once per router) the hooks backing `useRouteNavigating`, and returns the flag.
+ * `createAppRouter` calls this eagerly so the very first navigation is already covered.
+ */
+export declare function installRouteNavigating(router: Router): ShallowRef<boolean>;
+/**
+ * Reports whether a route navigation is in flight — the vue-router counterpart of react-router's
+ * `useNavigation().state !== 'idle'`, covering lazy-chunk loads and async guards.
+ *
+ * Resolves the router by injection when none is passed, and reads `false` forever when there is no
+ * router at all, so `<NavigationProgress mode="manual">` works in a router-less tree.
+ */
+export declare function useRouteNavigating(router?: Router): ComputedRef<boolean>;

package/dist/router/UseTypedSearchParams.d.ts

@@ -0,0 +1,17 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+/** Defines the typed search-params accessor — the current values plus a partial, merge-preserving setter. */
+export interface TypedSearchParams<T extends Record<string, string>> {
+    /** The current values — each key resolved from the URL, falling back to its default. */
+    readonly values: ComputedRef<T>;
+    /** Sets a partial subset of keys, preserving every untouched param already in the URL. */
+    readonly setValues: (patch: Partial<T>) => void;
+}
+/**
+ * Manages typed URL search params — a read merged over `defaults` plus a merge-preserving partial setter.
+ * The read resolves each default key from the URL (falling back to its default); the setter patches only
+ * the given keys and leaves every other param (typed or not) untouched. For dashboard filters / pagination.
+ *
+ * `values` is a `ComputedRef` (React returned a bare object) so it tracks `route.query`; `defaults` may
+ * be a ref or getter when they themselves change.
+ */
+export declare function useTypedSearchParams<T extends Record<string, string>>(defaults: MaybeRefOrGetter<T>): TypedSearchParams<T>;