@kitbag/router 0.24.3 → 0.26.0

package/dist/{src/types → types}/resolved.d.ts

@@ -1,7 +1,14 @@
-import { Route, Routes } from './route';
+import { CreatedRouteOptions, Route, RouteDataOf, Routes } from './route';
+import { LastInArray } from './utilities';
 import { ExtractRouteStateParamsAsOptional } from './state';
 import { UrlString } from './urlString';
 import { UrlParamsReading } from './url';
+import { GetTitleCallback } from './routeTitle';
+/**
+ * The match a route resolved to, which is the last of its matches. Falls back to the wide match type when
+ * the matches are not a concrete tuple, so an unregistered router stays assignable.
+ */
+type MatchedRoute<TMatches> = LastInArray<TMatches, CreatedRouteOptions> extends infer TMatched ? unknown extends TMatched ? CreatedRouteOptions : TMatched : never;
 /**
  * Represents a route that the router has matched to current browser location.
  * @template TRoute - Underlying Route that has been resolved.
@@ -14,7 +21,7 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
     /**
      * The specific route properties that were matched in the current route.
     */
-    matched: TRoute['matched'];
+    matched: MatchedRoute<TRoute['matches']>;
     /**
      * The specific route properties that were matched in the current route, including any ancestors.
      * Order of routes will be from greatest ancestor to narrowest matched.
@@ -45,10 +52,23 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      */
     hash: string;
     /**
-     * Title of the route.
+     * Returns the title of the route from its `setTitle` callback, or from the closest parent route that
+     * defines one.
      */
-    title: Promise<string | undefined>;
+    getTitle: GetTitleCallback;
 }>;
+/**
+ * A resolved route whose loaders' data is available. Only the route being navigated to has data: a route
+ * the router merely resolved is not being loaded, so data on it could never settle. The current route and
+ * a props getter's route have it, `router.resolve` and hooks do not.
+ */
+export type WithData<TRoute extends Route = Route> = {
+    /**
+     * What the route's loaders resolve to, keyed by loader name. A route whose only loader is unnamed
+     * exposes that loader's data here directly. Always promises, since loaders never block rendering.
+     */
+    data: RouteDataOf<TRoute['matches']>;
+};
 /**
  * This type is the same as `ResolvedRoute<TRoutes[number]>` while remaining distributive
  */
@@ -65,3 +85,4 @@ export type RouterResolvedRouteUnion<TRoutes extends Routes> = {
  * type ResolvedUnion = ResolvedRouteUnion<RouteUnion> // ResolvedRoute<RouteA> | ResolvedRoute<RouteB>
  */
 export type ResolvedRouteUnion<TRoute extends Route> = TRoute extends Route ? ResolvedRoute<TRoute> : never;
+export {};

package/dist/types/resolved.spec-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/route.d.ts

@@ -0,0 +1,121 @@
+import { Param } from './paramTypes';
+import { PrefetchConfig } from './prefetch';
+import { RouteMeta } from './register';
+import { LastInArray } from './utilities';
+import { CreateRouteOptions } from './createRouteOptions';
+import { RouteContext, ToRouteContext } from './routeContext';
+import { ToMeta } from './meta';
+import { ToState } from './state';
+import { Url } from './url';
+import { GetRouteTitle } from './routeTitle';
+import { Hooks } from '../models/hooks';
+import { RouteRedirect } from './redirects';
+import { RouteViews } from './routeViews';
+import { LoadersDataReturnType, RouteLoaders } from './routeLoaders';
+export declare const IS_ROUTE_SYMBOL: unique symbol;
+export declare function isRoute(value: unknown): value is Route & RouteInternal;
+export type RouteInternal = {
+    [IS_ROUTE_SYMBOL]: true;
+    depth: number;
+    hooks: Hooks[];
+    redirect: RouteRedirect;
+    getTitle: GetRouteTitle;
+};
+/**
+ * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
+ */
+export type Routes = readonly Route[];
+/**
+ * The Route properties originally provided to `createRoute`, plus the views that route renders and the
+ * loaders it runs. The deprecated `component`/`components` options are folded into `views` (see
+ * {@link RouteViews}).
+ */
+export type CreatedRouteOptions = Omit<CreateRouteOptions, 'component' | 'components'> & {
+    id: string;
+    views: RouteViews;
+    loaders: RouteLoaders;
+};
+/**
+ * The name of the narrowest matched route.
+ */
+type RouteNameOf<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    name: infer TName extends string;
+} ? TName : string;
+/**
+ * The meta of every matched route, combined. Mirrors `combineMeta`, which is an intersection.
+ */
+type RouteMetaOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteMeta : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? ToMeta<THead extends {
+    meta: infer TMeta extends RouteMeta;
+} ? TMeta : undefined> & RouteMetaOf<TRest> : {};
+/**
+ * The state of every matched route, combined. Mirrors `combineState`, which is an intersection.
+ * A match without state contributes `{}` rather than `ToState<undefined>`, which widens to
+ * `Record<string, Param>` and would swallow the rest of the intersection.
+ */
+type RouteStateOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? Record<string, Param> : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? (THead extends {
+    state: infer TState extends Record<string, Param>;
+} ? ToState<TState> : {}) & RouteStateOf<TRest> : {};
+/**
+ * The loaders of every matched route, combined. A plain intersection: a loader name is unique across a
+ * route and its ancestors, which `addLoader` enforces.
+ */
+type RouteLoadersOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteLoaders : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? (THead extends {
+    loaders: infer TLoaders extends RouteLoaders;
+} ? TLoaders : {}) & RouteLoadersOf<TRest> : {};
+/**
+ * The data every matched route's loaders resolve to, which is what a resolved route exposes as `data`.
+ * Undefined when nothing in the route tree declares a loader.
+ */
+export type RouteDataOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? Promise<unknown> | Record<string, Promise<unknown>> | undefined : LoadersDataReturnType<RouteLoadersOf<TMatches>>;
+/**
+ * The context of every matched route, flattened from greatest ancestor to narrowest matched.
+ */
+type RouteContextOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteContext[] : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? [...ToRouteContext<THead extends {
+    context: infer TContext extends RouteContext[];
+} ? TContext : []>, ...RouteContextOf<TRest>] : [];
+/**
+ * Represents the structure of a route within the application. Return value of `createRoute`
+ * @template TUrl - The url the route resolves to, combined with any parents. Intersected into the route.
+ * @template TMatches - The options of the route and its ancestors, indexed by depth. Name, meta, state,
+ * and context are all derived from this, including each route's views.
+ */
+export type Route<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = TUrl & {
+    /**
+     * Unique identifier for the route, generated by router.
+    */
+    id: string;
+    /**
+     * The specific route properties that were matched in the current route, including any ancestors.
+     * Order of routes will be from greatest ancestor to narrowest matched.
+    */
+    matches: TMatches;
+    /**
+     * Identifier for the route as defined by user. Name must be unique among named routes. Name is used for routing and for matching.
+    */
+    name: RouteNameOf<TMatches>;
+    /**
+     * Represents additional metadata associated with a route, combined with any parents.
+    */
+    meta: RouteMetaOf<TMatches>;
+    /**
+     * Represents the schema of the route state, combined with any parents.
+    */
+    state: RouteStateOf<TMatches>;
+    /**
+     * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
+    */
+    prefetch?: PrefetchConfig;
+    /**
+     * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
+     */
+    context: RouteContextOf<TMatches>;
+};
+export type GenericRoute = Url & {
+    id: string;
+    name: string;
+    matches: CreatedRouteOptions[];
+    meta: RouteMeta;
+    state: Record<string, Param>;
+    prefetch?: PrefetchConfig;
+};
+export {};

package/dist/types/route.spec-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/routeCallbackContext.d.ts

@@ -0,0 +1,30 @@
+import { ResolvedRoute } from './resolved';
+import { CreatedRouteOptions, Route } from './route';
+import { RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { RouterPush } from './routerPush';
+import { RouterReject } from './routerReject';
+import { RouterReplace } from './routerReplace';
+import { RouteUpdate } from './routeUpdate';
+import { LoadersDataReturnType } from './routeLoaders';
+import { ViewsPropsReturnType } from './routeViews';
+/**
+ * Context provided to a callback attached to a route — an `addView` props getter, or a loader. Sourced
+ * from the route: rejections/routes from the route's context, and the parent from the route's `matches`.
+ */
+export type RouteCallbackContext<TRoute extends Route> = {
+    reject: RouterReject<RouteContextToRejection<TRoute['context']>>;
+    push: RouterPush<[TRoute] | RouteContextToRoute<TRoute['context']>>;
+    replace: RouterReplace<[TRoute] | RouteContextToRoute<TRoute['context']>>;
+    update: RouteUpdate<ResolvedRoute<TRoute>>;
+    parent: RouteCallbackParent<TRoute>;
+};
+/**
+ * The parent context ({ name, props, data }) reconstructed from the second-to-last `matches` entry, which
+ * carries the parent's name, its views and its loaders.
+ */
+type RouteCallbackParent<TRoute extends Route> = TRoute['matches'] extends [...CreatedRouteOptions[], infer TParent extends CreatedRouteOptions, CreatedRouteOptions] ? {
+    name: TParent['name'];
+    props: ViewsPropsReturnType<TParent['views']>;
+    data: LoadersDataReturnType<TParent['loaders']>;
+} : undefined;
+export {};

package/dist/types/routeLoaders.d.ts

@@ -0,0 +1,32 @@
+import { AnyPayloadTransformer } from '../services/payload';
+import { PrefetchConfig } from './prefetch';
+import { AnyFunction } from './utilities';
+/**
+ * A single loader: how to load its data, and how to prefetch it. Unlike a view, a loader always has a
+ * getter — a loader without one would have nothing to contribute.
+ *
+ * @template TData - What this loader's getter returns, carried so a route's data can be typed from it.
+ */
+export type RouteLoader<TData = unknown> = {
+    load: AnyFunction<TData>;
+    prefetch?: PrefetchConfig;
+    transformer?: AnyPayloadTransformer;
+};
+/**
+ * The loaders for a single route, keyed by loader name (the unnamed loader under 'default').
+ */
+export type RouteLoaders = Record<string, RouteLoader>;
+/**
+ * The data a set of loaders resolves to. A lone unnamed loader is given directly rather than under a
+ * 'default' key, matching how the loader is written. Each loader's data is always a promise, since a
+ * loader never blocks rendering, even when the loader itself is synchronous.
+ */
+export type LoadersDataReturnType<TLoaders> = keyof TLoaders extends never ? undefined : keyof TLoaders extends 'default' ? LoaderData<Extract<TLoaders, {
+    default: unknown;
+}>['default']> : {
+    [K in keyof TLoaders]: LoaderData<TLoaders[K]>;
+};
+type LoaderData<TLoader> = TLoader extends {
+    load: AnyFunction<infer TData>;
+} ? Promise<Awaited<TData>> : never;
+export {};

package/dist/types/routeTitle.browser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{src/types → types}/routeTitle.d.ts

@@ -1,9 +1,10 @@
 import { ResolvedRoute, ResolvedRouteUnion } from './resolved';
 import { Route } from './route';
 import { MaybePromise } from './utilities';
+export type GetTitleCallback = () => Promise<string | undefined>;
 export type SetRouteTitleContext = {
     from: ResolvedRoute;
-    getParentTitle: () => Promise<string | undefined>;
+    getParentTitle: GetTitleCallback;
 };
 export type SetRouteTitleCallback<TRoute extends Route = Route> = (to: ResolvedRouteUnion<TRoute>, context: SetRouteTitleContext) => MaybePromise<string>;
 export type GetRouteTitle<TRoute extends Route = Route> = (to: ResolvedRouteUnion<TRoute>) => Promise<string | undefined>;

package/dist/types/routeViews.d.ts

@@ -0,0 +1,46 @@
+import { AnyPayloadTransformer } from '../services/payload';
+import { Component } from 'vue';
+import { PrefetchConfig } from './prefetch';
+import { AnyFunction } from './utilities';
+/**
+ * A single view: what to render, how to get its props, and how to prefetch it. `component` is optional
+ * because a route can bind props to the nested RouterView it renders without declaring a component.
+ *
+ * @template TProps - What this view's props getter returns, carried so parent props can be typed from it.
+ */
+export type RouteView<TProps = undefined> = {
+    component?: Component;
+    props?: AnyFunction<TProps>;
+    prefetch?: PrefetchConfig;
+    transformer?: AnyPayloadTransformer;
+};
+/**
+ * The views for a single route, keyed by view name (the unnamed view under 'default'). Indexed by depth in
+ * `route.views` — parallel to how `route.matches` indexes the matched options, which is where a route's id
+ * comes from at a given depth.
+ */
+export type RouteViews = Record<string, RouteView<unknown>>;
+/**
+ * The props a child sees for a parent's views. A lone unnamed view is given directly rather than under a
+ * 'default' key, matching how the props argument is written. Each view's props are always a promise,
+ * since the parent's props may not have been computed when the child's getter runs.
+ */
+export type ViewsPropsReturnType<TViews> = keyof ViewsWithProps<TViews> extends never ? undefined : keyof ViewsWithProps<TViews> extends 'default' ? ParentViewProps<Extract<ViewsWithProps<TViews>, {
+    default: unknown;
+}>['default']> : {
+    [K in keyof ViewsWithProps<TViews>]: ParentViewProps<ViewsWithProps<TViews>[K]>;
+};
+type ViewsWithProps<TViews> = {
+    [K in keyof TViews as HasViewProps<TViews[K]> extends true ? K : never]: TViews[K];
+};
+/**
+ * A view has props unless its getter is absent, which is carried as props resolving to undefined. Asked
+ * both ways because a getter that only ever throws resolves to never, which is assignable to undefined
+ * without being the absent case.
+ */
+type HasViewProps<TView> = [ViewProps<TView>] extends [undefined] ? [undefined] extends [ViewProps<TView>] ? false : true : true;
+type ViewProps<TView> = TView extends {
+    props?: AnyFunction<infer TProps>;
+} ? TProps : undefined;
+type ParentViewProps<TView> = Promise<Awaited<ViewProps<TView>>>;
+export {};

package/dist/types/routeWithMethods.d.ts

@@ -0,0 +1,16 @@
+import { RouteAddLoader } from './addLoader';
+import { RouteAddView } from './addView';
+import { InternalRouteHooks } from './hooks';
+import { RouteRedirects } from './redirects';
+import { CreatedRouteOptions, Route } from './route';
+import { RouteSetTitle } from './routeTitle';
+import { Url } from './url';
+/**
+ * A route plus every chainable/available method: addView, addLoader, hooks, redirects, and title. The type
+ * level counterpart to `withRouteMethods`.
+ *
+ * Takes the url and matches rather than an assembled route so that adding a view or a loader can rebuild
+ * from them directly. Taking the route would mean re-deriving the url from it on every call, and that
+ * reference is what made chained calls nest one inside the last.
+ */
+export type RouteWithMethods<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = Route<TUrl, TMatches> & RouteAddView<TUrl, TMatches> & RouteAddLoader<TUrl, TMatches> & InternalRouteHooks<Route<TUrl, TMatches>, Route<TUrl, TMatches>['context']> & RouteRedirects<Route<TUrl, TMatches>> & RouteSetTitle<Route<TUrl, TMatches>>;

package/dist/types/routeWithParams.spec-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{src/types → types}/router.d.ts

@@ -1,5 +1,6 @@
 import { App, InjectionKey, Ref } from 'vue';
 import { RouterHistoryMode } from '../services/createRouterHistory';
+import { TransformerOptions } from '../services/payload';
 import { RouterRoute } from './routerRoute';
 import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from './hooks';
 import { PrefetchConfig } from './prefetch';
@@ -12,16 +13,22 @@ import { RouterReject } from './routerReject';
 import { RouterPlugin } from './routerPlugin';
 import { RoutesName } from './routesMap';
 import { ExtractRejections, ExtractRejectionTypes, Rejections, BuiltInRejectionType } from './rejection';
+import { PayloadValueError } from '../errors/payloadValueError';
 /**
  * Options to initialize a {@link Router} instance.
  */
-export type RouterOptions = {
+export type RouterOptions = TransformerOptions & {
     /**
      * Initial URL for the router to use. Required if using Node environment. Defaults to window.location when using browser.
      *
      * @default window.location.toString()
      */
     initialUrl?: string;
+    /**
+     * Marks the router as rendering on a server, so every navigation is part of the server render from
+     * the moment the router is created. Required to call `render`.
+     */
+    ssr?: boolean;
     /**
      * Specifies the history mode for the router, such as "browser", "memory", or "hash".
      *
@@ -47,6 +54,19 @@ export type RouterOptions = {
      * @default true
      */
     removeTrailingSlashes?: boolean;
+    /**
+     * The status `render` responds with for a normalized url or a route redirect that does not declare
+     * its own.
+     *
+     * @default 302
+     */
+    redirectStatus?: RedirectStatus;
+    /**
+     * The status `render` responds with for a rejection that does not declare its own.
+     *
+     * @default 200
+     */
+    rejectStatus?: number;
     /**
      * When false, createRouterAssets must be used for component and hooks. Assets exported by the library
      * will not work with the created router instance.
@@ -55,6 +75,67 @@ export type RouterOptions = {
      */
     isGlobalRouter?: boolean;
 };
+/**
+ * What a server should respond with for what the router rendered. `location` exists only on a redirect,
+ * so narrowing on it is what proves a `Location` header is available.
+ */
+export type ServerRenderResponse = RenderSuccess | RenderReject | RenderRedirect;
+export type RenderSuccess = {
+    kind: 'success';
+    /**
+     * Suggested http status.
+     */
+    status: number;
+    /**
+     * A script tag to embed in the document sent to the client, so it adopts what this render settled on
+     * rather than working it out again.
+     */
+    payload: string;
+    /**
+     * The title of the route that rendered, for the document sent to the client.
+     */
+    title: string | undefined;
+    /**
+     * Values that could not be encoded into the payload. Each was left out, so the client computes it
+     * again, which can cause a hydration mismatch. Returned so a server can log or inspect them.
+     */
+    failures: PayloadValueError[];
+};
+export type RenderReject = {
+    kind: 'reject';
+    /**
+     * Suggested http status.
+     */
+    status: number;
+    /**
+     * The type of rejection in effect.
+     */
+    rejection: string;
+    /**
+     * A script tag to embed in the document sent to the client, so it adopts this rejection rather than
+     * working it out again.
+     */
+    payload: string;
+    /**
+     * The title of the rejection that rendered, for the document sent to the client.
+     */
+    title: string | undefined;
+};
+export type RenderRedirect = {
+    kind: 'redirect';
+    /**
+     * Suggested http status.
+     */
+    status: RedirectStatus;
+    /**
+     * Value for the `Location` header.
+     */
+    location: string;
+};
+/**
+ * The statuses the router reports for a redirect.
+ */
+export type RedirectStatus = 301 | 302;
 export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions = any, TPlugin extends RouterPlugin = any> = {
     /**
      * Installs the router into a Vue application instance.
@@ -129,7 +210,7 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      * Registers a hook to be called when an error occurs.
      * If the hook returns true, the error is considered handled and the other hooks are not run. If all hooks return false the error is rethrown
      */
-    onError: AddErrorHook<TRoutes[number] | TPlugin['routes'][number], TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
+    onError: AddErrorHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called when a rejection occurs.
      */
@@ -151,7 +232,18 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      */
     started: Ref<boolean>;
     /**
-     * Stops the router and teardown any listeners.
+     * Resolves once the router has nothing left to render: every prop and loader has settled, following
+     * any navigation one of them caused, so this waits for the next *full* render rather than for one
+     * navigation. Resolves with what a server should respond with.
+     *
+     * Awaiting `push` only waits for the route to commit; this also waits for its data.
+     *
+     * Requires the router to be created with the `ssr` option, and throws `SsrOptionRequiredError`
+     * without it.
+     */
+    render: () => Promise<ServerRenderResponse>;
+    /**
+     * Stops the router. Tears down the history listener and ignores any navigation still in flight or started afterwards.
      */
     stop: () => void;
     /**

package/dist/{src/types → types}/routerPlugin.d.ts

@@ -43,13 +43,17 @@ type PluginAfterRouteHookContext<TRoutes extends Routes, TRejections extends Rej
     replace: RouterReplace<TRoutes>;
 };
 export type PluginBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute, context: PluginBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+export type PluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute | null, context: PluginBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+type AddPluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: PluginBeforeRouteLeaveHook<TRoutes, TRejections>) => HookRemove;
+export type PluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute | null, context: PluginAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+type AddPluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: PluginAfterRouteLeaveHook<TRoutes, TRejections>) => HookRemove;
 export type PluginAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute, context: PluginAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
 type AddPluginBeforeRouteHook<TRoutes extends Routes, TRejections extends Rejections> = (hook: PluginBeforeRouteHook<TRoutes, TRejections>) => HookRemove;
 type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejections> = (hook: PluginAfterRouteHook<TRoutes, TRejections>) => HookRemove;
 export type PluginErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
-    to: ResolvedRoute;
+    to: ResolvedRoute | null;
     from: ResolvedRoute | null;
-    source: 'props' | 'hook' | 'component';
+    source: 'props' | 'loader' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
@@ -64,7 +68,7 @@ export type PluginRouteHooks<TRoutes extends Routes = Routes, TRejections extend
     /**
      * Registers a global hook to be called before a route is left.
      */
-    onBeforeRouteLeave: AddPluginBeforeRouteHook<TRoutes, TRejections>;
+    onBeforeRouteLeave: AddPluginBeforeRouteLeaveHook<TRoutes, TRejections>;
     /**
      * Registers a global hook to be called before a route is updated.
      */
@@ -76,7 +80,7 @@ export type PluginRouteHooks<TRoutes extends Routes = Routes, TRejections extend
     /**
      * Registers a global hook to be called after a route is left.
      */
-    onAfterRouteLeave: AddPluginAfterRouteHook<TRoutes, TRejections>;
+    onAfterRouteLeave: AddPluginAfterRouteLeaveHook<TRoutes, TRejections>;
     /**
      * Registers a global hook to be called after a route is updated.
      */

package/dist/types/routerReject.d.ts

@@ -0,0 +1,15 @@
+import { BuiltInRejectionType, Rejections, RejectionType } from './rejection';
+import { ResolvedRoute } from './resolved';
+export type RouterReject<TRejections extends Rejections | undefined> = <TSource extends (RejectionType<TRejections> | BuiltInRejectionType)>(type: TSource) => void;
+/**
+ * The routes a rejection happened between, which rejection hooks are given.
+ */
+export type RejectContext = {
+    to?: ResolvedRoute | null;
+    from?: ResolvedRoute | null;
+};
+/**
+ * Reject as the router itself calls it, which may name any rejection type and supply the routes the
+ * rejection happened between. The router exposes {@link RouterReject} instead.
+ */
+export type RouterRejectInternal<TRejections extends Rejections | undefined> = RouterReject<TRejections> & ((type: string, context?: RejectContext) => void);

package/dist/{src/types → types}/routerRoute.d.ts

@@ -1,5 +1,6 @@
 import { RouteUpdate } from './routeUpdate';
 import { ResolvedRoute } from './resolved';
+import { RouteDataOf } from './route';
 import { QuerySource } from './querySource';
 export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
     /**
@@ -34,7 +35,12 @@ export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
     /**
      * Title of the route.
      */
-    readonly title: TRoute['title'];
+    readonly getTitle: TRoute['getTitle'];
+    /**
+     * What the route's loaders resolve to, keyed by loader name. A route whose only loader is unnamed
+     * exposes that loader's data here directly.
+     */
+    readonly data: RouteDataOf<TRoute['matches']>;
     params: TRoute['params'];
     state: TRoute['state'];
     get query(): URLSearchParams;

package/dist/types/routesMap.spec-ts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/serverRenderResponse.spec-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{src/types → types}/utilities.d.ts

@@ -4,6 +4,7 @@ export type Identity<T> = T extends object ? {} & {
 type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
 export type LastInArray<T, TFallback = never> = T extends [...any[], infer Last] ? Last : TFallback;
 export type MaybePromise<T> = T | Promise<T>;
+export type AnyFunction<TReturn = any> = (...args: any[]) => TReturn;
 type OnlyRequiredProperties<T> = {
     [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
 };

package/dist/utilities/checkDuplicateNames.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/checkDuplicateParams.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/components.d.ts

@@ -0,0 +1,18 @@
+import { Component } from 'vue';
+import { ResolvedRoute } from '../types/resolved';
+import { CreatedRouteOptions } from '../types/route';
+import { RouteView } from '../types/routeViews';
+type ComponentWithAsyncLoader = Component & {
+    __asyncLoader: () => Promise<unknown>;
+};
+export declare function isAsyncComponent(component: Component): component is ComponentWithAsyncLoader;
+/**
+ * Decides which of a route's views to load.
+ */
+export type AsyncComponentFilter = (match: CreatedRouteOptions, view: RouteView<unknown>) => boolean;
+/**
+ * Loads the async components a route renders, or only those the filter keeps, so they are ready to render
+ * synchronously.
+ */
+export declare function loadAsyncComponents(route: ResolvedRoute, filter?: AsyncComponentFilter): Promise<unknown>;
+export {};

package/dist/utilities/components.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/guards.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/isBrowser.browser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/isBrowser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{src/utilities → utilities}/prefetch.d.ts

@@ -1,4 +1,4 @@
 import { PrefetchConfig, PrefetchConfigOptions, PrefetchConfigs, PrefetchStrategy } from '../types/prefetch';
 export declare const DEFAULT_PREFETCH_STRATEGY: PrefetchStrategy;
-export declare function getPrefetchOption({ routerPrefetch, routePrefetch, linkPrefetch }: PrefetchConfigs, setting: keyof PrefetchConfigOptions): false | PrefetchStrategy;
+export declare function getPrefetchOption({ routerPrefetch, routePrefetch, viewPrefetch, linkPrefetch }: PrefetchConfigs, setting: keyof PrefetchConfigOptions): false | PrefetchStrategy;
 export declare function getPrefetchConfigValue(prefetch: PrefetchConfig | undefined, setting: keyof PrefetchConfigOptions): boolean | PrefetchStrategy | undefined;

package/dist/utilities/prefetch.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/props.d.ts

@@ -0,0 +1,16 @@
+import { MaybePromise } from '../types/utilities';
+/**
+ * How a props getter settled. Tagged so that a getter returning `undefined` or an `Error` stays a value.
+ */
+export type PropsResult = {
+    kind: 'value';
+    value: unknown;
+} | {
+    kind: 'error';
+    error: unknown;
+};
+/**
+ * Runs a props callback and captures how it settled rather than letting it throw, so that navigation can
+ * tell a push or rejection apart from a genuine failure. Sync getters settle synchronously.
+ */
+export declare function getPropsValue(callback: () => unknown): MaybePromise<PropsResult>;

package/dist/utilities/setDocumentTitle.d.ts

@@ -0,0 +1 @@
+export declare function setDocumentTitle(title: string | undefined): void;