@kitbag/router 0.27.0 → 0.29.0

package/dist/main.d.ts

@@ -1,6 +1,6 @@
 import { RouterAssets } from './services/createRouterAssets';
 import { RegisteredRouter } from './types/register';
-export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, PropsGetter, RouterViewPropsGetter, CreateRouteProps, ToRoute } from './types/createRouteOptions';
+export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, ToRoute } from './types/createRouteOptions';
 export type { RouteAddView, AddViewOptions, AddViewPropsGetter, AddViewPropsCallbackContext } from './types/addView';
 export type { RouteAddLoader, AddLoaderOptions, LoaderGetter } from './types/addLoader';
 export type { RouteAddAlias, AddAliasOptions } from './types/addAlias';
@@ -8,6 +8,7 @@ export type { AliasTransform, AliasTransformContext } from './types/routeAlias';
 export type { RouteCallbackContext } from './types/routeCallbackContext';
 export type { RouteViews } from './types/routeViews';
 export type { RouteLoader, RouteLoaders } from './types/routeLoaders';
+export type { CreateLoaderOptions, Loader, LoaderCallbackContext } from './types/loader';
 export type { RejectionHooks, HookRemove, BeforeHookLifecycle, AfterHookLifecycle, HookLifecycle, BeforeEnterHookContext, BeforeEnterHook, AddBeforeEnterHook, BeforeUpdateHookContext, BeforeUpdateHook, AddBeforeUpdateHook, BeforeLeaveHookContext, BeforeLeaveHook, AddBeforeLeaveHook, AfterEnterHookContext, AfterEnterHook, AddAfterEnterHook, AfterUpdateHookContext, AfterUpdateHook, AddAfterUpdateHook, AfterLeaveHookContext, AfterLeaveHook, AddAfterLeaveHook, RejectionHookContext, RejectionHook, AddRejectionHook, ErrorHookContext, ErrorHook, AddErrorHook } from './types/hooks';
 export * from './types/paramTypes';
 export * from './types/prefetch';
@@ -34,6 +35,7 @@ export * from './types/routerRoute';
 export * from './types/urlString';
 export type { Url, CreateUrlOptions, ParseUrlOptions } from './types/url';
 export * from './types/useLink';
+export * from './types/viewTransition';
 export * from './types/navigation';
 export { DuplicateParamsError } from './errors/duplicateParamsError';
 export { LoaderDataAccessError } from './errors/loaderDataAccessError';
@@ -45,6 +47,8 @@ export { RouterNotInstalledError } from './errors/routerNotInstalledError';
 export { UseRouteInvalidError } from './errors/useRouteInvalidError';
 export { SsrOptionRequiredError } from './errors/ssrOptionRequiredError';
 export { UnreachableRouteError } from './errors/unreachableRouteError';
+export type { CreateHookOptions, Hook, HookCallbackContext } from './types/hook';
+export type { CreateViewOptions, View, ViewCallbackContext } from './types/view';
 export { createRoute } from './services/createRoute';
 export { createRejection } from './services/createRejection';
 export { createExternalRoute } from './services/createExternalRoute';
@@ -59,6 +63,19 @@ export { literal } from './services/literal';
 export { createParam } from './services/createParam';
 export { createRouter } from './services/createRouter';
 export { createUrl } from './services/createUrl';
+export type { ViewTransitionProps } from './components/viewTransition';
+/**
+ * Creates a reusable hook with callbacks typed to the registered router's resolved routes.
+ */
+export declare const createHook: RouterAssets<RegisteredRouter>['createHook'];
+/**
+ * Creates a reusable view with props callbacks typed to the registered router's resolved routes.
+ */
+export declare const createView: RouterAssets<RegisteredRouter>['createView'];
+/**
+ * Creates a reusable loader with callbacks typed to the registered router's resolved routes.
+ */
+export declare const createLoader: RouterAssets<RegisteredRouter>['createLoader'];
 /**
  * Registers a hook that is called before a route is left. Must be called from setup.
  * This is useful for performing actions or cleanups before navigating away from a route component.
@@ -119,6 +136,8 @@ export declare const RouterView: RouterAssets<RegisteredRouter>['RouterView'];
  * @group Components
  */
 export declare const RouterLink: RouterAssets<RegisteredRouter>['RouterLink'];
+/** Names a shared element for a view transition. @group Components */
+export declare const ViewTransition: new <TElement extends keyof HTMLElementTagNameMap = "span">(props: import('./main').ViewTransitionProps<TElement>) => import('vue').ComponentPublicInstance<import('./main').ViewTransitionProps<TElement>>;
 /**
  * A component to render a bar across the top of the page while a navigation is pending, filled by how
  * much of the navigation's work has settled.
@@ -179,6 +198,13 @@ export declare const useLink: RouterAssets<RegisteredRouter>['useLink'];
  * @group Compositions
  */
 export declare const useRejection: RouterAssets<RegisteredRouter>['useRejection'];
+/**
+ * A composition to access the view transition in flight, if any.
+ *
+ * @returns The router's view transition state.
+ * @group Compositions
+ */
+export declare const useViewTransition: RouterAssets<RegisteredRouter>['useViewTransition'];
 /**
  * A composition to access the navigation under way: whether one is pending, which routes it leaves and
  * leads to, and how much of the work it waits on has settled.

package/dist/models/hooks.d.ts

@@ -1,13 +1,15 @@
-import { AfterEnterHook, AfterLeaveHook, AfterUpdateHook, BeforeEnterHook, BeforeLeaveHook, BeforeUpdateHook, ErrorHook, RejectionHook } from '../types/hooks';
+import { AnyHook } from '../types/hook';
+import { ComponentHook, AfterEnterHook, AfterLeaveHook, AfterUpdateHook, BeforeEnterHook, BeforeLeaveHook, BeforeUpdateHook, ErrorHook, RejectionHook } from '../types/hooks';
 import { RedirectHook } from '../types/redirects';
 export declare class Hooks {
+    onHookAdded: Set<(hook: ComponentHook | AnyHook) => void>;
     redirects: Set<RedirectHook>;
-    onBeforeRouteEnter: Set<BeforeEnterHook>;
-    onBeforeRouteUpdate: Set<BeforeUpdateHook>;
-    onBeforeRouteLeave: Set<BeforeLeaveHook>;
-    onAfterRouteEnter: Set<AfterEnterHook>;
-    onAfterRouteUpdate: Set<AfterUpdateHook>;
-    onAfterRouteLeave: Set<AfterLeaveHook>;
+    onBeforeRouteEnter: Set<AnyHook | BeforeEnterHook>;
+    onBeforeRouteUpdate: Set<AnyHook | BeforeUpdateHook>;
+    onBeforeRouteLeave: Set<AnyHook | BeforeLeaveHook>;
+    onAfterRouteEnter: Set<AnyHook | AfterEnterHook>;
+    onAfterRouteUpdate: Set<AnyHook | AfterUpdateHook>;
+    onAfterRouteLeave: Set<AnyHook | AfterLeaveHook>;
     onError: Set<ErrorHook>;
     onRejection: Set<RejectionHook>;
 }

package/dist/services/addLoader.d.ts

@@ -2,6 +2,8 @@ import { AnyPayloadTransformer } from './payload';
 import { PrefetchConfig } from '../types/prefetch';
 import { CreatedRouteOptions, Route } from '../types/route';
 import { AnyFunction } from '../types/utilities';
+import { AnyLoader } from '../types/loader';
+import { RouteContext } from '../types/routeContext';
 export declare const DEFAULT_LOADER_NAME = "default";
 /**
  * The loose runtime shape of the `addLoader` options. Purposely wide: the name type each
@@ -15,7 +17,7 @@ type LoaderOptions = {
 /**
  * The runtime arguments accepted by `addLoader`.
  */
-type AddLoaderParameters = [load: AnyFunction, options?: LoaderOptions];
+type AddLoaderParameters = [load: AnyFunction | AnyLoader, options?: LoaderOptions];
 /**
  * The loose runtime signature of the `addLoader` method. Purposely wide: it returns Route rather than the
  * refined chainable route each `RouteAddLoader` overload describes.
@@ -26,15 +28,16 @@ type Loader = {
     load: AnyFunction;
     prefetch: PrefetchConfig | undefined;
     transformer: AnyPayloadTransformer | undefined;
+    context?: readonly RouteContext[];
 };
-export declare function toLoader(load: AnyFunction, options: LoaderOptions | undefined): Loader;
+export declare function toLoader(source: AnyFunction | AnyLoader, options: LoaderOptions | undefined): Loader;
 /**
  * Returns a new match with the loader merged into its loaders under the loader's name.
  *
  * Matches are `markRaw` so that making a route reactive does not turn its loaders into reactive proxies.
  * Spreading a match drops that, so the rebuilt one is marked again.
  */
-export declare function addLoaderToMatch(match: CreatedRouteOptions, { name, load, prefetch, transformer }: Loader): CreatedRouteOptions;
+export declare function addLoaderToMatch(match: CreatedRouteOptions, loader: Loader): CreatedRouteOptions;
 /**
  * A route's data combines the loaders of every match, so a name an ancestor already uses would be
  * ambiguous. Adding a loader the route itself already has is an override, and allowed.

package/dist/services/addRedirect.d.ts

@@ -0,0 +1,3 @@
+import { RouteRedirectCallback, RouteRedirectOptions } from '../types/redirects';
+import { Route } from '../types/route';
+export declare function addRedirect<TRouteFrom extends Route, TRouteTo extends Route>(from: TRouteFrom, to: TRouteTo, convertParams?: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions): void;

package/dist/services/addRedirect.spec.d.ts

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

package/dist/services/addView.d.ts

@@ -1,40 +1,43 @@
 import { Component } from 'vue';
 import { AnyPayloadTransformer } from './payload';
-import { PropsGetter } from '../types/createRouteOptions';
+import { AddViewPropsGetter } from '../types/addView';
 import { PrefetchConfig } from '../types/prefetch';
 import { CreatedRouteOptions, Route } from '../types/route';
+import { AnyView } from '../types/view';
+import { RouteContext } from '../types/routeContext';
 /**
  * The loose runtime shape of the `addView` options. Purposely wide: the getter and name types each
  * `RouteAddView` describes are refined per route and component.
  */
 type ViewOptions = {
     name?: string;
-    props?: PropsGetter;
+    props?: AddViewPropsGetter<Route, Component>;
     prefetch?: PrefetchConfig;
     transformer?: AnyPayloadTransformer;
 };
 /**
  * The runtime arguments accepted by `addView`.
  */
-type AddViewParameters = [component: Component, options?: ViewOptions];
+type AddViewParameters = [component: Component | AnyView, options?: ViewOptions];
 /**
  * The loose runtime signature of the `addView` method. Purposely wide: it returns Route rather than the
  * refined chainable route each `RouteAddView` overload describes.
  */
 export type AddView = (...args: AddViewParameters) => Route;
 type View = {
+    context?: readonly RouteContext[];
     name: string;
     component: Component;
-    props: PropsGetter | undefined;
+    props?: AddViewPropsGetter<Route, Component>;
     prefetch: PrefetchConfig | undefined;
     transformer: AnyPayloadTransformer | undefined;
 };
-export declare function toView(component: Component, options: ViewOptions | undefined): View;
+export declare function toView(source: Component | AnyView, options: ViewOptions | undefined): View;
 /**
  * Returns a new match with the view merged into its views under the view's name.
  *
  * Matches are `markRaw` so that making a route reactive does not turn its components into reactive
  * proxies. Spreading a match drops that, so the rebuilt one is marked again.
  */
-export declare function addViewToMatch(match: CreatedRouteOptions, { name, component, props, prefetch, transformer }: View): CreatedRouteOptions;
+export declare function addViewToMatch(match: CreatedRouteOptions, view: View): CreatedRouteOptions;
 export {};

package/dist/services/combineContext.d.ts

@@ -0,0 +1,2 @@
+import { RouteContext } from '../types/routeContext';
+export declare function combineContext(parent?: readonly RouteContext[], child?: readonly RouteContext[]): RouteContext[];

package/dist/services/createHook.d.ts

@@ -0,0 +1,7 @@
+import { RouteContext } from '../types/routeContext';
+import { CreateHookOptions, Hook } from '../types/hook';
+import { Routes } from '../types/route';
+/**
+ * Creates a reusable hook with navigation helpers from its declared context.
+ */
+export declare function createHook<const TContext extends readonly RouteContext[] = [], TRoutes extends Routes = Routes>(options: CreateHookOptions<TContext, TRoutes>): Hook<TContext>;

package/dist/services/createHook.spec-d.d.ts

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

package/dist/services/createHook.spec.d.ts

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

package/dist/services/createLoader.d.ts

@@ -0,0 +1,7 @@
+import { Routes } from '../types/route';
+import { CreateLoaderOptions, Loader } from '../types/loader';
+import { RouteContext } from '../types/routeContext';
+/**
+ * Creates a reusable loader that receives the resolved route when an attached route is loaded.
+ */
+export declare function createLoader<const TContext extends readonly RouteContext[] = [], TData = unknown, TRoutes extends Routes = Routes>(options: CreateLoaderOptions<TContext, TData, TRoutes>): Loader<TData, TContext>;

package/dist/services/createLoader.spec-d.d.ts

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

package/dist/services/createLoader.spec.d.ts

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

package/dist/services/createRoute.d.ts

@@ -1,5 +1,3 @@
-import { CreateRouteOptions, PropsGetter, CreateRouteProps, ToRouteMatches, ToRouteUrl, RouterViewPropsGetter } from '../types/createRouteOptions';
+import { CreateRouteOptions, ToRouteMatches, ToRouteUrl } from '../types/createRouteOptions';
 import { RouteWithMethods } from '../types/routeWithMethods';
-type CreateRouteWithProps<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions>> = CreateRouteProps<TOptions> extends RouterViewPropsGetter<TOptions> ? [props?: RouterViewPropsGetter<TOptions>] : CreateRouteProps<TOptions> extends PropsGetter<TOptions> ? Partial<ReturnType<CreateRouteProps<TOptions>>> extends ReturnType<CreateRouteProps<TOptions>> ? [props?: TProps] : [props: TProps] : Partial<CreateRouteProps<TOptions>> extends CreateRouteProps<TOptions> ? [props?: TProps] : [props: TProps];
-export declare function createRoute<const TOptions extends CreateRouteOptions, const TProps extends CreateRouteProps<TOptions>>(options: TOptions, ...args: CreateRouteWithProps<TOptions, TProps>): RouteWithMethods<ToRouteUrl<TOptions>, ToRouteMatches<TOptions, TProps>>;
-export {};
+export declare function createRoute<const TOptions extends CreateRouteOptions>(options: TOptions): RouteWithMethods<ToRouteUrl<TOptions>, ToRouteMatches<TOptions>>;

package/dist/services/createRouter.d.ts

@@ -17,8 +17,8 @@ import { EmptyRouterPlugin, RouterPlugin } from '../types/routerPlugin';
  * const About = { template: '<div>About</div>' }
  *
  * export const routes = [
- *   createRoute({ name: 'home', path: '/', component: Home }),
- *   createRoute({ name: 'path', path: '/about', component: About }),
+ *   createRoute({ name: 'home', path: '/' }).addView(Home),
+ *   createRoute({ name: 'path', path: '/about' }).addView(About),
  * ] as const
  *
  * const router = createRouter(routes)

package/dist/services/createRouterAssets.d.ts

@@ -1,3 +1,7 @@
+import { CreateHook } from '../types/hook';
+import { CreateView } from '../types/view';
+import { CreateLoader } from '../types/loader';
+import { ViewTransition } from '../components/viewTransition';
 import { Router, RouterRoutes, RouterRejections } from '../types/router';
 import { InjectionKey } from 'vue';
 import { createRouterView } from '../components/routerView';
@@ -10,8 +14,21 @@ import { createUseLink } from '../compositions/useLink';
 import { createIsRoute } from '../guards/routes';
 import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../types/hooks';
 import { createUseRejection } from '../compositions/useRejection';
+import { createUseViewTransition } from '../compositions/useViewTransition';
 import { createUseNavigation } from '../compositions/useNavigation';
 export type RouterAssets<TRouter extends Router> = {
+    /**
+     * Creates a reusable hook with callbacks typed to this router's resolved routes.
+     */
+    createHook: CreateHook<RouterRoutes<TRouter>>;
+    /**
+     * Creates a reusable view with props callbacks typed to this router's resolved routes and loader data.
+     */
+    createView: CreateView<RouterRoutes<TRouter>>;
+    /**
+     * Creates a reusable loader with callbacks typed to this router's resolved routes.
+     */
+    createLoader: CreateLoader<RouterRoutes<TRouter>>;
     /**
      * Registers a hook that is called before a route is left. Must be called from setup.
      * This is useful for performing actions or cleanups before navigating away from a route component.
@@ -72,6 +89,8 @@ export type RouterAssets<TRouter extends Router> = {
      * @group Components
      */
     RouterLink: ReturnType<typeof createRouterLink<TRouter>>;
+    /** Names a shared element for a view transition. @group Components */
+    ViewTransition: typeof ViewTransition;
     /**
      * A component to render a bar across the top of the page while a navigation is pending, filled by how
      * much of the navigation's work has settled.
@@ -132,6 +151,13 @@ export type RouterAssets<TRouter extends Router> = {
      * @group Compositions
      */
     useRejection: ReturnType<typeof createUseRejection<TRouter>>;
+    /**
+     * A composition to access the view transition in flight, if any.
+     *
+     * @returns The router's view transition state.
+     * @group Compositions
+     */
+    useViewTransition: ReturnType<typeof createUseViewTransition<TRouter>>;
     /**
      * A composition to access the navigation under way: whether one is pending, which routes it leaves and
      * leads to, and how much of the work it waits on has settled.

package/dist/services/createRouterAssets.spec-d.d.ts

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

package/dist/services/createRouterHistory.d.ts

@@ -1,4 +1,4 @@
-import { History, Listener } from './history';
+import { History, Update } from './history';
 type NavigationPushOptions = {
     replace?: boolean;
     state?: unknown;
@@ -12,8 +12,16 @@ type RouterHistory = History & {
     stopListening: () => void;
 };
 export type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
+/** Called by the router while the traversal navigation is active. */
+export type RouterHistoryTraversal = {
+    commit: () => void;
+    restore: () => void;
+};
+type RouterHistoryUpdate = Update & {
+    traversal?: RouterHistoryTraversal;
+};
 type RouterHistoryOptions = {
-    listener: Listener;
+    listener: (event: RouterHistoryUpdate) => void;
     mode?: RouterHistoryMode;
 };
 export declare function createRouterHistory({ mode, listener }: RouterHistoryOptions): RouterHistory;

package/dist/services/createRouterHooks.d.ts

@@ -1,4 +1,5 @@
-import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook, RejectionHookRunner, AddRejectionHook } from '../types/hooks';
+import { AnyHook } from '../types/hook';
+import { ComponentHook, AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook, RejectionHookRunner, AddRejectionHook } from '../types/hooks';
 import { HasVueAppStore } from './createVueAppStore';
 import { RedirectStatus } from '../types/router';
 export declare const getRouterHooksKey: (routerKey: import('vue').InjectionKey<import('../types/router').Router>) => import('vue').InjectionKey<RouterHooks>;
@@ -20,6 +21,7 @@ export type RouterHooks = HasVueAppStore & {
 };
 type RouterHooksOptions = {
     redirectStatus: RedirectStatus;
+    onHookAdded?: (hook: ComponentHook | AnyHook) => void;
 };
-export declare function createRouterHooks({ redirectStatus }: RouterHooksOptions): RouterHooks;
+export declare function createRouterHooks({ redirectStatus, onHookAdded }: RouterHooksOptions): RouterHooks;
 export {};

package/dist/services/createView.d.ts

@@ -0,0 +1,10 @@
+import { Routes } from '../types/route';
+import { Component } from 'vue';
+import { ComponentProps } from './component';
+import { MaybePromise } from '../types/utilities';
+import { RouteContext } from '../types/routeContext';
+import { CreateViewOptions, View } from '../types/view';
+/**
+ * Creates a reusable view that receives the resolved route when computing its props.
+ */
+export declare function createView<TComponent extends Component, const TContext extends readonly RouteContext[] = [], TProps extends MaybePromise<ComponentProps<TComponent>> | undefined = undefined, TRoutes extends Routes = Routes>(options: CreateViewOptions<TComponent, TContext, TProps, TRoutes>): View<TProps, TContext>;

package/dist/services/createView.spec-d.d.ts

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

package/dist/services/createView.spec.d.ts

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

package/dist/services/createViewTransitions.browser.spec.d.ts

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

package/dist/services/createViewTransitions.d.ts

@@ -0,0 +1,38 @@
+import { ResolvedRoute } from '../types/resolved';
+import { RouterViewTransition, ViewTransitionTypes } from '../types/viewTransition';
+export type PendingViewTransition = {
+    to: ResolvedRoute;
+    from: ResolvedRoute;
+    types: ViewTransitionTypes;
+};
+export type ViewTransitions = {
+    /**
+     * The transition in flight, as the router exposes it.
+     */
+    viewTransition: RouterViewTransition;
+    /**
+     * Records the navigation about to transition, ahead of its data loading, so the page being left can
+     * prepare before it is captured.
+     */
+    prepare: (navigation: PendingViewTransition) => void;
+    /**
+     * Forgets a prepared navigation that was superseded before it transitioned, unless a newer one has
+     * taken over the state since.
+     */
+    cancel: (navigation: PendingViewTransition) => void;
+    /**
+     * Forgets the transition in flight, for a navigation that commits without one.
+     */
+    reset: () => void;
+    /**
+     * Runs the update inside a view transition. Resolves after the update and Vue flush, ahead of the animation.
+     */
+    start: (update: () => void | Promise<unknown>) => Promise<void>;
+};
+/**
+ * Owns the one transition the document runs at a time. Starting another while the first has not yet run
+ * its callback leaves the browser free to run the two callbacks in either order, so a navigation arriving
+ * then takes over the pending callback instead. Once the callback has run the browser skips the old
+ * animation on its own.
+ */
+export declare function createViewTransitions(): ViewTransitions;

package/dist/services/getRouteContext.d.ts

@@ -0,0 +1,6 @@
+import { Route } from '../types/route';
+import { RouteContext } from '../types/routeContext';
+/**
+ * Collects a route's context, including loaders and views merged during attachment, and its hooks' context.
+ */
+export declare function getRouteContext(route: Route): RouteContext[];

package/dist/services/getRoutesForRouter.d.ts

@@ -2,6 +2,9 @@ import { Route, RouteInternal, Routes } from '../types/route';
 import { RouterPlugin } from '../types/routerPlugin';
 import { BuiltInRejectionType, Rejection, RejectionInternal } from '../types/rejection';
 import { RouterOptions } from '../types/router';
+import { AnyHook } from '../types/hook';
+import { ComponentHook } from '../types/hooks';
+import { RouteContext } from '../types/routeContext';
 /**
  * Takes in routes and plugins and returns a list of routes with the base route inserted if provided.
  * Also checks for duplicate names and unreachable paths in the routes.
@@ -17,11 +20,13 @@ export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?:
         meta: Record<string, unknown>;
         state: Record<string, import('../main').Param>;
         prefetch?: import('../main').PrefetchConfig;
-        context: import('../types/routeContext').RouteContext[];
+        context: RouteContext[];
     } & RouteInternal)[];
     rejections: (Pick<import('../types/rejection').RejectionOptions<string>, "type" | "status"> & {
         getTitle: import('../types/routeTitle').GetTitleCallback;
     } & RejectionInternal)[];
+    addHookContext: (hook: ComponentHook | AnyHook) => void;
+    stop: () => void;
     getRouteByName: (type: string) => Route | undefined;
     getRejectionByType: {
         (type: BuiltInRejectionType): (Rejection & RejectionInternal);

package/dist/services/history.d.ts

@@ -23,6 +23,7 @@ export interface Transition extends Update {
 export type Blocker = (tx: Transition) => void;
 export type To = string | Partial<Path>;
 export interface History {
+    readonly index: number | null;
     readonly action: Action;
     readonly location: Location;
     createHref: (to: To) => string;

package/dist/services/registerHookContext.spec.d.ts

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

package/dist/services/routeViews.d.ts

@@ -0,0 +1,7 @@
+import { RouteViews } from '../types/routeViews';
+export declare const DEFAULT_VIEW_NAME = "default";
+/**
+ * The names of the views that have a props getter. A view without one is never computed, so waiting on it
+ * would never settle.
+ */
+export declare function viewNamesWithProps(views: RouteViews): string[];

package/dist/services/toHook.d.ts

@@ -0,0 +1,3 @@
+import { AnyHook } from '../types/hook';
+import { AnyFunction } from '../types/utilities';
+export declare function toHook<THook extends AnyFunction>(hook: THook | AnyHook): THook | AnyHook['hook'];

package/dist/services/urlParser.d.ts

@@ -1,6 +1,6 @@
 import { QuerySource } from '../types/querySource';
 import { UrlString } from '../types/urlString';
-type UrlParts = {
+export type UrlParts = {
     host?: string;
     path: string;
     query: URLSearchParams;

package/dist/services/withRouteMethods.d.ts

@@ -1,7 +1,6 @@
 import { Route } from '../types/route';
 /**
- * Attaches the chainable, immutable route methods — `addView`, `addLoader`, and `addAlias`. Each call
- * rebuilds the route's own (last) match, or its aliases, and returns a new route with the methods
- * re-attached, so none mutates the route it was called on, and chaining one never drops another.
+ * Attaches methods and callbacks to the current route copy. Chaining a view, loader, or alias
+ * rebuilds the route and reattaches its methods.
  */
 export declare function withRouteMethods<TRoute extends Route>(route: TRoute): TRoute;

package/dist/tests/navigationBehavior.browser.spec.d.ts

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

package/dist/tests/viewTransitions.browser.spec.d.ts

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

package/dist/types/addLoader.d.ts

@@ -6,7 +6,9 @@ import { CreatedRouteOptions, Route } from './route';
 import { RouteCallbackContext } from './routeCallbackContext';
 import { RouteLoader, RouteLoaders } from './routeLoaders';
 import { Url } from './url';
-import { Identity, LastInArray } from './utilities';
+import { AnyFunction, Identity, LastInArray } from './utilities';
+import { AnyLoader } from './loader';
+import { RouteContext, WithRouteContext } from './routeContext';
 /**
  * The getter for a loader added via `addLoader`. Receives the same two arguments as an `addView` props
  * getter, except that its route carries no data: a route's data includes what the loader itself is
@@ -47,13 +49,13 @@ type LoaderName<TName extends string | undefined> = TName extends string ? TName
 /**
  * Replaces the loaders on the last match, preserving all ancestors.
  */
-type ReplaceLastMatchLoaders<TMatches extends CreatedRouteOptions[], TNewLoaders extends RouteLoaders> = TMatches extends [...infer THead extends CreatedRouteOptions[], infer TLast extends CreatedRouteOptions] ? Identity<Omit<TLast, 'loaders'> & {
+type ReplaceLastMatchLoaders<TMatches extends CreatedRouteOptions[], TNewLoaders extends RouteLoaders, TContext extends RouteContext[]> = TMatches extends [...infer THead extends CreatedRouteOptions[], infer TLast extends CreatedRouteOptions] ? Identity<Omit<WithRouteContext<TLast, TContext>, 'loaders'> & {
     loaders: TNewLoaders;
 }> extends infer TNext extends CreatedRouteOptions ? [...THead, TNext] : TMatches : TMatches;
 /**
  * The full return type of an `addLoader` call: the same url with the last match's loaders replaced.
  */
-type AddLoaderReturn<TUrl extends Url, TMatches extends CreatedRouteOptions[], TNewLoaders extends RouteLoaders> = ReplaceLastMatchLoaders<TMatches, TNewLoaders> extends infer TNext extends CreatedRouteOptions[] ? RouteWithMethods<TUrl, TNext> : never;
+type AddLoaderReturn<TUrl extends Url, TMatches extends CreatedRouteOptions[], TName extends string | undefined, TData, TContext extends RouteContext[] = []> = ReplaceLastMatchLoaders<TMatches, AddLoaderLoaders<CurrentMatchLoaders<TMatches>, TName, TData>, TContext> extends infer TNext extends CreatedRouteOptions[] ? RouteWithMethods<TUrl, TNext> : never;
 /**
  * Adds a loader to a route. Chainable to register multiple loaders, each exposed under its own name on
  * the resolved route's `data`.
@@ -65,6 +67,7 @@ export type RouteAddLoader<TUrl extends Url = Url, TMatches extends CreatedRoute
      * @param load - The loader callback. Receives the resolved route and a context object.
      * @param options - The loader's `name` and `prefetch` config.
      */
-    addLoader: <const TName extends string | undefined = undefined, const TGetter extends LoaderGetter<Route<TUrl, TMatches>> = LoaderGetter<Route<TUrl, TMatches>>>(load: TGetter, options?: AddLoaderOptions<TName, Awaited<ReturnType<TGetter>>>) => AddLoaderReturn<TUrl, TMatches, AddLoaderLoaders<CurrentMatchLoaders<TMatches>, TName, ReturnType<TGetter>>>;
+    addLoader: <const TSource extends LoaderGetter<Route<TUrl, TMatches>> | AnyLoader, const TName extends string | undefined = undefined>(load: TSource, options?: AddLoaderOptions<TName, Awaited<LoaderDataOf<TSource>>>) => AddLoaderReturn<TUrl, TMatches, TName, LoaderDataOf<TSource>, TSource extends AnyLoader ? [...TSource['context']] : []>;
 };
+type LoaderDataOf<TSource extends AnyFunction | AnyLoader> = ReturnType<TSource extends AnyLoader ? TSource['load'] : Extract<TSource, AnyFunction>>;
 export {};

package/dist/types/addView.d.ts

@@ -1,6 +1,7 @@
 import { Component } from 'vue';
+import { AnyView } from './view';
+import { RouteContext, WithRouteContext } from './routeContext';
 import { ComponentProps } from '../services/component';
-import { ComponentPropsAreOptional, PropsGetter } from './createRouteOptions';
 import { ResolvedRoute, WithData } from './resolved';
 import { CreatedRouteOptions, Route } from './route';
 import { RouteCallbackContext } from './routeCallbackContext';
@@ -11,8 +12,7 @@ import { RouteView, RouteViews } from './routeViews';
 import { Url } from './url';
 import { AnyFunction, Identity, LastInArray, MaybePromise } from './utilities';
 /**
- * The props getter for a view added via `addView`. Receives the same two arguments as the
- * `createRoute` props callback: the resolved route and a context object.
+ * The props getter for a view added via `addView`. Receives the resolved route and a context object.
  */
 export type AddViewPropsGetter<TRoute extends Route, TComponent extends Component> = (route: ResolvedRoute<TRoute> & WithData<TRoute>, context: AddViewPropsCallbackContext<TRoute>) => MaybePromise<ComponentProps<TComponent>>;
 /**
@@ -20,6 +20,7 @@ export type AddViewPropsGetter<TRoute extends Route, TComponent extends Componen
  * callbacks attached to a route.
  */
 export type AddViewPropsCallbackContext<TRoute extends Route> = RouteCallbackContext<TRoute>;
+type ComponentPropsAreOptional<TComponent extends Component> = Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? true : false;
 /**
  * When the getter is omitted the default type param resolves to the wide getter type, which then
  * "extends" itself and collapses to undefined. When a getter is provided its return type is kept — the
@@ -32,7 +33,7 @@ type NewViewProps<TRoute extends Route, TComponent extends Component, TGetter ex
  * @template TName - The view's name, inferred from the `name` option.
  * @template TGetter - The view's props getter, inferred from the `props` option.
  */
-export type AddViewOptions<TName extends string | undefined = string, TGetter = PropsGetter> = TransformerOptions<PayloadValueOf<TGetter>> & {
+export type AddViewOptions<TName extends string | undefined = string, TGetter = AddViewPropsGetter<Route, Component>> = TransformerOptions<PayloadValueOf<TGetter>> & {
     /**
      * The name of the view, rendered by `<router-view name="..." />`. Defaults to the unnamed view.
      */
@@ -84,13 +85,13 @@ type ViewName<TName extends string | undefined> = TName extends string ? TName :
 /**
  * Replaces the views on the last match, preserving all ancestors.
  */
-type ReplaceLastMatchViews<TMatches extends CreatedRouteOptions[], TNewViews extends RouteViews> = TMatches extends [...infer THead extends CreatedRouteOptions[], infer TLast extends CreatedRouteOptions] ? Identity<Omit<TLast, 'views'> & {
+type ReplaceLastMatchViews<TMatches extends CreatedRouteOptions[], TNewViews extends RouteViews, TContext extends RouteContext[]> = TMatches extends [...infer THead extends CreatedRouteOptions[], infer TLast extends CreatedRouteOptions] ? Identity<Omit<WithRouteContext<TLast, TContext>, 'views'> & {
     views: TNewViews;
 }> extends infer TNext extends CreatedRouteOptions ? [...THead, TNext] : TMatches : TMatches;
 /**
  * The full return type of an `addView` call: the same url with the last match's views replaced.
  */
-type AddViewReturn<TUrl extends Url, TMatches extends CreatedRouteOptions[], TNewProps extends RouteViews> = ReplaceLastMatchViews<TMatches, TNewProps> extends infer TNext extends CreatedRouteOptions[] ? RouteWithMethods<TUrl, TNext> : never;
+type AddViewReturn<TUrl extends Url, TMatches extends CreatedRouteOptions[], TName extends string | undefined, TProps, TContext extends RouteContext[] = []> = ReplaceLastMatchViews<TMatches, AddViewProps<CurrentMatchViews<TMatches>, TName, TProps>, TContext> extends infer TNext extends CreatedRouteOptions[] ? RouteWithMethods<TUrl, TNext> : never;
 /**
  * Adds a view (component + optional props getter) to a route. Chainable to register multiple views,
  * including named views for named `<router-view />`s.
@@ -104,6 +105,9 @@ export type RouteAddView<TUrl extends Url = Url, TMatches extends CreatedRouteOp
      * @param options - The view's `name`, `props` getter, and `prefetch` config. Required when the
      * component has required props, optional otherwise.
      */
-    addView: <TComponent extends Component, const TName extends string | undefined = undefined, const TGetter extends AddViewPropsGetter<Route<TUrl, TMatches>, TComponent> = AddViewPropsGetter<Route<TUrl, TMatches>, TComponent>>(component: TComponent, ...options: AddViewArgs<TComponent, TName, TGetter>) => AddViewReturn<TUrl, TMatches, AddViewProps<CurrentMatchViews<TMatches>, TName, NewViewProps<Route<TUrl, TMatches>, TComponent, TGetter>>>;
+    addView: <TSource extends Component | AnyView, const TName extends string | undefined = undefined, const TGetter extends AddViewPropsGetter<Route<TUrl, TMatches>, Extract<TSource, Component>> = AddViewPropsGetter<Route<TUrl, TMatches>, Extract<TSource, Component>>>(source: TSource, ...options: TSource extends AnyView ? [options?: Omit<AddViewOptions<TName, AnyFunction<ViewPropsOf<TSource>>>, 'props'>] : AddViewArgs<Extract<TSource, Component>, TName, TGetter>) => TSource extends AnyView ? AddViewReturn<TUrl, TMatches, TName, ViewPropsOf<TSource>, [...TSource['context']]> : AddViewReturn<TUrl, TMatches, TName, NewViewProps<Route<TUrl, TMatches>, Extract<TSource, Component>, TGetter>>;
 };
+type ViewPropsOf<TView extends AnyView> = TView extends {
+    props?: AnyFunction<infer TProps>;
+} ? TProps : undefined;
 export {};