@kitbag/router 0.27.0 → 0.29.0

package/dist/types/createRouteOptions.d.ts

@@ -1,20 +1,15 @@
-import { Component } from 'vue';
+import { NavigationBehavior } from './navigation';
 import { Param } from './paramTypes';
 import { PrefetchConfig } from './prefetch';
+import { ViewTransitionConfig } from './viewTransition';
 import { RouteMeta } from './register';
 import { Route, RouteInternal } from './route';
-import { ResolvedRoute, WithData } from './resolved';
-import { ComponentProps } from '../services/component';
-import { PropsCallbackContext } from './props';
-import { AnyFunction, Identity, MaybePromise } from './utilities';
 import { ToMeta } from './meta';
 import { ToName } from './name';
 import { UrlPart, UrlQueryPart } from '../services/withParams';
 import { RouteContext } from './routeContext';
-import { RouterViewProps } from '../components/routerView';
 import { ToUrl } from './url';
 import { CombineUrl } from '../services/combineUrl';
-import { RouteView } from './routeViews';
 export type WithHost<THost extends string | UrlPart = string | UrlPart> = {
     /**
      * Host part of URL.
@@ -31,20 +26,6 @@ export declare function isWithParent<T extends Record<string, unknown>>(options:
 export type WithoutParent = {
     parent?: never;
 };
-/**
- * This type is used to strip the component and components properties from the options object
- * when creating a Route to simplify and minimize the output type.
- */
-type WithoutComponents = {
-    component: never;
-    components: never;
-};
-export declare function isWithComponent<T extends Record<string, unknown>>(options: T): options is T & {
-    component: Component;
-};
-export declare function isWithComponents<T extends Record<string, unknown>>(options: T): options is T & {
-    components: Record<string, Component>;
-};
 export type CreateRouteOptions<TName extends string | undefined = string | undefined, TMeta extends RouteMeta = RouteMeta> = {
     /**
      * Name for route, used to create route keys and in navigation.
@@ -70,6 +51,12 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
      */
     prefetch?: PrefetchConfig;
+    /** Overrides the parent route and router navigation behavior. */
+    navigation?: NavigationBehavior;
+    /**
+     * Animates navigations to this route with the View Transitions API. Overrides router level viewTransition.
+     */
+    viewTransition?: ViewTransitionConfig;
     /**
      * Type params for additional data intended to be stored in history state, all keys will be optional unless a default is provided.
      */
@@ -79,20 +66,7 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      */
     parent?: Route;
     /**
-     * An optional component to render when this route is matched.
-     *
-     * @default RouterView
-     * @deprecated Use the chainable `addView` method on the route instead: `createRoute({ ... }).addView(component, { props })`.
-     */
-    component?: Component;
-    /**
-     * An object of named components to render using named views
-     *
-     * @deprecated Use the chainable `addView` method on the route instead: `createRoute({ ... }).addView(component, { name, props })`.
-     */
-    components?: Record<string, Component>;
-    /**
-     * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
+     * See [Context](https://kitbag-router.netlify.app/advanced-concepts/context).
      */
     context?: RouteContext[];
     /**
@@ -100,16 +74,7 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      */
     hoist?: boolean;
 };
-export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions>> & WithData<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<ComponentProps<TComponent>>;
-export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions>> & WithData<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
-export type ComponentPropsAreOptional<TComponent extends Component> = Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? true : false;
-type RoutePropsRecord<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponents extends Record<string, Component> = Record<string, Component>> = {
-    [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends true ? K : never]?: PropsGetter<TOptions, TComponents[K]>;
-} & {
-    [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends false ? K : never]: PropsGetter<TOptions, TComponents[K]>;
-};
-export type CreateRouteProps<TOptions extends CreateRouteOptions = CreateRouteOptions> = TOptions['component'] extends Component ? PropsGetter<TOptions, TOptions['component']> : TOptions['components'] extends Record<string, Component> ? RoutePropsRecord<TOptions, TOptions['components']> : RouterViewPropsGetter<TOptions>;
-type ToMatch<TOptions extends CreateRouteOptions, TProps = undefined> = Omit<TOptions, 'meta' | 'name' | 'component' | 'components' | 'parent'> & {
+type ToMatch<TOptions extends CreateRouteOptions> = Omit<TOptions, 'meta' | 'name' | 'parent'> & {
     id: string;
     name: ToName<TOptions['name']>;
     /**
@@ -117,9 +82,9 @@ type ToMatch<TOptions extends CreateRouteOptions, TProps = undefined> = Omit<TOp
      */
     meta: ToMeta<TOptions['meta']>;
     /**
-     * The views this route renders, keyed by view name.
+     * The views this route renders, keyed by view name. Added by `addView`.
      */
-    views: PropsToViews<TProps>;
+    views: {};
     /**
      * The loaders this route runs, keyed by loader name. Always empty here — loaders are only added via
      * the route's `addLoader`.
@@ -130,29 +95,16 @@ type ToMatch<TOptions extends CreateRouteOptions, TProps = undefined> = Omit<TOp
  * The matches for a route, from greatest ancestor to the route itself. Each carries its own views, so
  * there is no second tuple to keep aligned with this one.
  */
-type ToMatches<TOptions extends CreateRouteOptions, TProps = undefined> = TOptions extends {
-    parent: infer TParent extends Route;
-} ? [...TParent['matches'], ToMatch<TOptions, TProps>] : [ToMatch<TOptions, TProps>];
-/**
- * Builds a views record from the props argument, which is either a single getter for the unnamed view or
- * a record of getters keyed by view name.
- */
-type PropsToViews<TProps> = [TProps] extends [AnyFunction] ? {
-    default: RouteView<ReturnType<TProps>>;
-} : [TProps] extends [Record<string, AnyFunction>] ? {
-    [K in keyof TProps]: RouteView<ReturnType<TProps[K]>>;
-} : {};
+type ToMatches<TOptions extends CreateRouteOptions> = TOptions extends WithParent ? [...TOptions['parent']['matches'], ToMatch<TOptions>] : [ToMatch<TOptions>];
 /**
  * The url a route resolves to, combined with its parent's unless the route is hoisted.
  */
-export type ToRouteUrl<TOptions extends CreateRouteOptions> = TOptions extends {
-    parent: infer TParent extends Route;
-} ? TOptions['hoist'] extends true ? ToUrl<TOptions & WithoutComponents> : CombineUrl<TParent, ToUrl<TOptions & WithoutComponents>> : ToUrl<Identity<TOptions & WithoutComponents>>;
+export type ToRouteUrl<TOptions extends CreateRouteOptions> = TOptions extends WithParent ? TOptions['hoist'] extends true ? ToUrl<TOptions> : CombineUrl<TOptions['parent'], ToUrl<TOptions>> : ToUrl<TOptions>;
 /**
- * The matches for a route, with the props argument resolved to the views of its own match.
+ * The matches for a route, before any views or loaders are added.
  */
-export type ToRouteMatches<TOptions extends CreateRouteOptions, TProps> = ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>;
-export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined = undefined> = CreateRouteOptions extends TOptions ? Route : Route<ToRouteUrl<TOptions>, ToRouteMatches<TOptions, TProps>>;
+export type ToRouteMatches<TOptions extends CreateRouteOptions> = ToMatches<TOptions>;
+export type ToRoute<TOptions extends CreateRouteOptions> = CreateRouteOptions extends TOptions ? Route : Route<ToRouteUrl<TOptions>, ToRouteMatches<TOptions>>;
 /**
  * Nests a route under its parent. A hoisted route keeps everything of its parent's except the url: its own
  * url stands alone and it inherits none of the parent's aliases.

package/dist/types/hook.d.ts

@@ -0,0 +1,43 @@
+import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { ResolvedRouteUnion } from './resolved';
+import { Route, Routes } from './route';
+import { BeforeHookContext, AfterHookContext } from './hooks';
+import { RouteUpdate } from './routeUpdate';
+import { AnyFunction, MaybePromise } from './utilities';
+export declare const IS_HOOK_SYMBOL: unique symbol;
+export type HookInternal = {
+    [IS_HOOK_SYMBOL]: true;
+};
+/**
+ * Context provided to a reusable hook, narrowed by whether it runs before or after navigation.
+ */
+export type HookCallbackContext<TContext extends readonly RouteContext[] = [], TRoutes extends Routes = Routes> = {
+    from: ResolvedRouteUnion<TRoutes[number]> | null;
+    update?: RouteUpdate;
+} & (Omit<BeforeHookContext<Route, RouteContextToRoute<[...TContext]>, RouteContextToRejection<[...TContext]>>, 'update'> | Omit<AfterHookContext<Route, RouteContextToRoute<[...TContext]>, RouteContextToRejection<[...TContext]>>, 'update'>);
+/**
+ * Options for a reusable route hook.
+ */
+export type CreateHookOptions<TContext extends readonly RouteContext[] = [], TRoutes extends Routes = Routes> = {
+    hook: (route: ResolvedRouteUnion<TRoutes[number]> | null, context: HookCallbackContext<TContext, TRoutes>) => MaybePromise<void>;
+    /**
+     * See [Context](https://kitbag-router.netlify.app/advanced-concepts/context).
+     */
+    context?: TContext;
+};
+/**
+ * Creates hooks with callbacks typed to the router's resolved routes.
+ */
+export type CreateHook<TRoutes extends Routes = Routes> = <const TContext extends readonly RouteContext[] = []>(options: CreateHookOptions<TContext, TRoutes>) => Hook<TContext>;
+/**
+ * A reusable hook that can be attached before or after a route enters, updates, or leaves.
+ */
+export type Hook<TContext extends readonly RouteContext[] = []> = {
+    hook: AnyFunction<MaybePromise<void>>;
+    context: TContext;
+};
+export type AnyHook = Hook<readonly RouteContext[]>;
+/**
+ * Determines whether a value is a reusable hook.
+ */
+export declare function isHook(value: unknown): value is AnyHook & HookInternal;

package/dist/types/hooks.d.ts

@@ -1,6 +1,7 @@
+import { AnyHook } from './hook';
 import { Hooks } from '../models/hooks';
 import { RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
-import { MaybePromise } from './utilities';
+import { AnyFunction, MaybePromise } from './utilities';
 import { Route, Routes } from './route';
 import { RouterReject } from './routerReject';
 import { RouterPush } from './routerPush';
@@ -61,7 +62,7 @@ export type ComponentHook = BeforeEnterHook | BeforeUpdateHook | BeforeLeaveHook
  */
 export type ComponentHookRegistration = {
     lifecycle: HookLifecycle;
-    hook: ComponentHook;
+    hook: ComponentHook | AnyHook;
     depth: number;
 };
 /**
@@ -73,6 +74,10 @@ export type AddGlobalHooks = (hooks: Hooks) => void;
  * A function to remove a previously added route hook.
  */
 export type HookRemove = () => void;
+/**
+ * Registers an inline callback or a reusable hook definition.
+ */
+export type AddHook<THook extends AnyFunction> = (hook: THook | AnyHook) => HookRemove;
 /**
  * Enumerates the lifecycle events for before route hooks.
  */
@@ -85,14 +90,16 @@ export type AfterHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'o
  * Union type for all route hook lifecycle events.
  */
 export type HookLifecycle = BeforeHookLifecycle | AfterHookLifecycle;
-type AfterHookContext<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
+export type AfterHookContext<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
+    lifecycle: 'after';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
     update: RouteUpdate<ResolvedRouteUnion<TRoute>>;
     signal: AbortSignal;
 };
-type BeforeHookContext<TRouteTo extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
+export type BeforeHookContext<TRouteTo extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
+    lifecycle: 'before';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
@@ -104,32 +111,32 @@ export type BeforeEnterHookContext<TRoutes extends Routes = Routes, TRejections
     from: ResolvedRouteUnion<TRouteFrom> | null;
 };
 export type BeforeEnterHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: BeforeEnterHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
-export type AddBeforeEnterHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: BeforeEnterHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
+export type AddBeforeEnterHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AddHook<BeforeEnterHook<TRoutes, TRejections, TRouteTo, TRouteFrom>>;
 export type BeforeUpdateHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = BeforeHookContext<TRouteTo, TRoutes, TRejections> & {
     from: ResolvedRouteUnion<TRouteFrom> | null;
 };
 export type BeforeUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: BeforeUpdateHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
-export type AddBeforeUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: BeforeUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
+export type AddBeforeUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AddHook<BeforeUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>>;
 export type BeforeLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = Omit<BeforeHookContext<TRouteTo, TRoutes, TRejections>, 'update'> & {
     from: ResolvedRouteUnion<TRouteFrom>;
 };
 export type BeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo> | null, context: BeforeLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
-export type AddBeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: BeforeLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
+export type AddBeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AddHook<BeforeLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>>;
 export type AfterEnterHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AfterHookContext<TRouteTo, TRoutes, TRejections> & {
     from: ResolvedRouteUnion<TRouteFrom> | null;
 };
 export type AfterEnterHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: AfterEnterHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
-export type AddAfterEnterHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: AfterEnterHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
+export type AddAfterEnterHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AddHook<AfterEnterHook<TRoutes, TRejections, TRouteTo, TRouteFrom>>;
 export type AfterUpdateHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AfterHookContext<TRouteTo, TRoutes, TRejections> & {
     from: ResolvedRouteUnion<TRouteFrom> | null;
 };
 export type AfterUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: AfterUpdateHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
-export type AddAfterUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: AfterUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
+export type AddAfterUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AddHook<AfterUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>>;
 export type AfterLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = Omit<AfterHookContext<TRouteTo, TRoutes, TRejections>, 'update'> & {
     from: ResolvedRouteUnion<TRouteFrom>;
 };
 export type AfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo> | null, context: AfterLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
-export type AddAfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: AfterLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
+export type AddAfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AddHook<AfterLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>>;
 export type BeforeHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextRedirect | CallbackContextReject | CallbackContextAbort;
 export type AfterHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject;
 export type HookRunnerContext<TRoutes extends Routes = Routes> = {
@@ -167,4 +174,3 @@ export type ErrorHookRunnerContext<TRoutes extends Routes = Routes> = {
     source: 'props' | 'loader' | 'hook';
 };
 export type ErrorHookRunner = (error: unknown, context: ErrorHookRunnerContext) => void;
-export {};

package/dist/types/loader.d.ts

@@ -0,0 +1,59 @@
+import { TransformerOptions } from '../services/payload';
+import { PrefetchConfig } from './prefetch';
+import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { RouterPush } from './routerPush';
+import { RouterReject } from './routerReject';
+import { RouterReplace } from './routerReplace';
+import { AnyFunction } from './utilities';
+import { ResolvedRouteUnion } from './resolved';
+import { Routes } from './route';
+export declare const IS_LOADER_SYMBOL: unique symbol;
+export type LoaderInternal = {
+    [IS_LOADER_SYMBOL]: true;
+};
+/**
+ * Navigation helpers available to a reusable loader, typed from its declared context.
+ */
+export type LoaderCallbackContext<TContext extends readonly RouteContext[] = []> = {
+    push: RouterPush<RouteContextToRoute<[...TContext]>>;
+    replace: RouterReplace<RouteContextToRoute<[...TContext]>>;
+    reject: RouterReject<RouteContextToRejection<[...TContext]>>;
+    signal: AbortSignal;
+};
+/**
+ * Options for a reusable loader that receives the resolved route and its declared context helpers.
+ */
+export type CreateLoaderOptions<TContext extends readonly RouteContext[] = [], TData = unknown, TRoutes extends Routes = Routes> = TransformerOptions<NoInfer<Awaited<TData>>> & {
+    /**
+     * Loads a value or promise from the resolved route.
+     */
+    load: (route: ResolvedRouteUnion<TRoutes[number]>, context: LoaderCallbackContext<TContext>) => TData;
+    /**
+     * See [Context](https://kitbag-router.netlify.app/advanced-concepts/context).
+     */
+    context?: TContext;
+    /**
+     * Default prefetch behavior, overridable when attaching the loader.
+     */
+    prefetch?: PrefetchConfig;
+};
+/**
+ * Creates loaders with callbacks typed to the router's resolved routes.
+ */
+export type CreateLoader<TRoutes extends Routes = Routes> = <const TContext extends readonly RouteContext[] = [], TData = unknown>(options: CreateLoaderOptions<TContext, TData, TRoutes>) => Loader<TData, TContext>;
+/**
+ * A reusable loader definition, with its context normalized to an array.
+ */
+export type Loader<TData = unknown, TContext extends readonly RouteContext[] = []> = TransformerOptions<Awaited<TData>> & {
+    load: AnyFunction<TData>;
+    context: TContext;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The runtime shape after a loader's route, context, and return types have been erased.
+ */
+export type AnyLoader = Loader<any, readonly RouteContext[]>;
+/**
+ * Determines whether a value is a reusable loader created by `createLoader`.
+ */
+export declare function isLoader(value: unknown): value is AnyLoader & LoaderInternal;

package/dist/types/navigation.d.ts

@@ -1,5 +1,7 @@
 import { ComputedRef } from 'vue';
 import { ResolvedRoute } from './resolved';
+/** Whether navigation commits immediately or waits for its props, loaders, and components. */
+export type NavigationBehavior = 'progressive' | 'blocking';
 /**
  * The navigation under way, if any, and how far it has come. A navigation is under way from the moment it
  * is asked for until the route it leads to has everything it renders with, or it is rejected, aborted, or

package/dist/types/props.d.ts

@@ -1,25 +1,7 @@
-import { CreateRouteOptions } from './createRouteOptions';
 import { Route } from './route';
-import { RouterReject } from './routerReject';
-import { RouterPush } from './routerPush';
-import { RouterReplace } from './routerReplace';
-import { ExtractRouteContextRejections, ExtractRouteContextRoutes } from './routeContext';
-import { ResolvedRoute } from './resolved';
-import { RouteUpdate } from './routeUpdate';
 import { LoadersDataReturnType } from './routeLoaders';
 import { ViewsPropsReturnType } from './routeViews';
 import { LastInArray } from './utilities';
-/**
- * Context provided to props callback functions
- */
-export type PropsCallbackContext<TRoute extends Route = Route, TOptions extends CreateRouteOptions = CreateRouteOptions> = {
-    reject: RouterReject<ExtractRouteContextRejections<TOptions>>;
-    push: RouterPush<[TRoute] | ExtractRouteContextRoutes<TOptions>>;
-    replace: RouterReplace<[TRoute] | ExtractRouteContextRoutes<TOptions>>;
-    update: RouteUpdate<ResolvedRoute<TRoute>>;
-    signal: AbortSignal;
-    parent: PropsCallbackParent<TOptions['parent']>;
-};
 export type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
     name: string;
     props: unknown;

package/dist/types/register.d.ts

@@ -19,8 +19,8 @@ export interface Register {
  * Represents the Router property within {@link Register}
  */
 export type RegisteredRouter<T = Register> = T extends {
-    router: infer TRouter;
-} ? TRouter : Router;
+    router: unknown;
+} ? T['router'] : Router;
 /**
  * Represents additional metadata associated with a route, customizable via declaration merging.
  */

package/dist/types/resolved.d.ts

@@ -105,4 +105,8 @@ 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;
+/**
+ * Converts a route union to resolved routes with their corresponding loader data.
+ */
+export type ResolvedRouteWithDataUnion<TRoute extends Route> = TRoute extends Route ? ResolvedRoute<TRoute> & WithData<TRoute> : never;
 export {};

package/dist/types/route.d.ts

@@ -29,10 +29,9 @@ export type RouteInternal = {
 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}).
+ * loaders it runs.
  */
-export type CreatedRouteOptions = Omit<CreateRouteOptions, 'component' | 'components'> & {
+export type CreatedRouteOptions = CreateRouteOptions & {
     id: string;
     views: RouteViews;
     loaders: RouteLoaders;

package/dist/types/routeContext.d.ts

@@ -3,6 +3,14 @@ import { Rejection, Rejections } from './rejection';
 import { GenericRoute, Route, Routes } from './route';
 export type RouteContext = GenericRoute | Rejection;
 export type ToRouteContext<TContext extends RouteContext[] | readonly RouteContext[] | undefined> = TContext extends RouteContext[] ? TContext : [];
+/**
+ * Adds context to an options type while preserving its existing properties and context.
+ */
+export type WithRouteContext<TOptions extends {
+    context?: RouteContext[];
+}, TContext extends RouteContext[]> = TContext extends [] ? TOptions : Omit<TOptions, 'context'> & {
+    context: [...ToRouteContext<TOptions['context']>, ...TContext];
+};
 export type ExtractRouteContext<TOptions extends CreateRouteOptions> = TOptions extends {
     context: infer TContext extends RouteContext[];
 } ? TOptions extends {

package/dist/types/routeViews.d.ts

@@ -3,26 +3,24 @@ 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.
+ * A single view: what to render, how to get its props, and how to prefetch it.
  *
  * @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;
+    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.
+ * The views for a single match, keyed by view name (the unnamed view under 'default'). Each match in
+ * `route.matches` carries its own views.
  */
 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,
+ * 'default' key. 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>, {

package/dist/types/routeWithParams.d.ts

@@ -2,4 +2,4 @@ import { Route, Routes } from './route';
 import { RoutesName, RoutesMap } from './routesMap';
 import { UrlParamsWriting } from './url';
 export type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesName<TRoutes>> = RoutesMap<TRoutes>[TKey];
-export type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = RouteGetByKey<TRoutes, TKey> extends Route ? UrlParamsWriting<RouteGetByKey<TRoutes, TKey>> : Record<string, unknown>;
+export type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = TKey extends string ? RouteGetByKey<TRoutes, TKey> extends Route ? UrlParamsWriting<RouteGetByKey<TRoutes, TKey>> : Record<string, unknown> : never;

package/dist/types/router.d.ts

@@ -1,3 +1,4 @@
+import { NavigationBehavior } from './navigation';
 import { App, InjectionKey, Ref } from 'vue';
 import { RouterHistoryMode } from '../services/createRouterHistory';
 import { TransformerOptions } from '../services/payload';
@@ -5,7 +6,7 @@ import { RouterRoute } from './routerRoute';
 import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from './hooks';
 import { PrefetchConfig } from './prefetch';
 import { ResolvedRoute } from './resolved';
-import { Route, Routes } from './route';
+import { Routes } from './route';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
 import { RouterResolve, RouterResolveOptions } from './routerResolve';
@@ -14,6 +15,7 @@ import { RouterPlugin } from './routerPlugin';
 import { RoutesName } from './routesMap';
 import { ExtractRejections, ExtractRejectionTypes, Rejections, BuiltInRejectionType } from './rejection';
 import { PayloadValueError } from '../errors/payloadValueError';
+import { ViewTransitionConfig } from './viewTransition';
 /**
  * Options to initialize a {@link Router} instance.
  */
@@ -44,6 +46,17 @@ export type RouterOptions = TransformerOptions & {
      * Determines what assets are prefetched when router-link is rendered for a specific route
      */
     prefetch?: PrefetchConfig;
+    /**
+     * Whether navigation waits for props, loaders, and components before committing.
+     * @default 'progressive'
+     */
+    navigation?: NavigationBehavior;
+    /**
+     * Animates navigations with the View Transitions API. Overridden per route and per navigation.
+     *
+     * @default false
+     */
+    viewTransition?: ViewTransitionConfig;
     /**
      * Components assigned to each type of rejection your router supports.
      */
@@ -243,7 +256,8 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      */
     render: () => Promise<ServerRenderResponse>;
     /**
-     * Stops the router. Tears down the history listener and ignores any navigation still in flight or started afterwards.
+     * Stops the router. Releases history listeners and context subscriptions and ignores any navigation
+     * still in flight or started afterwards. Called automatically when the Vue app unmounts.
      */
     stop: () => void;
     /**
@@ -265,6 +279,6 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
 export type RouterRouteUnion<TRoutes extends Routes> = {
     [K in keyof TRoutes]: TRoutes[K]['name'] extends '' ? never : RouterRoute<ResolvedRoute<TRoutes[K]>>;
 }[number];
-export type RouterRoutes<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? TRoutes : Routes;
+export type RouterRoutes<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes, any, infer TPlugin extends RouterPlugin> ? Routes extends TRoutes | TPlugin['routes'] ? Routes : TRoutes | TPlugin['routes'] : Routes;
 export type RouterRejections<TRouter extends Router> = TRouter extends Router<any, infer TOptions extends RouterOptions, infer TPlugins extends RouterPlugin> ? ExtractRejections<TOptions> | ExtractRejections<TPlugins> : [];
-export type RouterRouteName<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? RoutesName<TRoutes> : RoutesName<Route[]>;
+export type RouterRouteName<TRouter extends Router> = RoutesName<RouterRoutes<TRouter>>;

package/dist/types/routerPlugin.d.ts

@@ -1,4 +1,4 @@
-import { HookRemove } from './hooks';
+import { AddHook, HookRemove } from './hooks';
 import { Routes } from './route';
 import { Rejections } from './rejection';
 import { Hooks } from '../models/hooks';
@@ -30,6 +30,7 @@ export type RouterPlugin<TRoutes extends Routes = Routes, TRejections extends Re
     rejections: TRejections;
 };
 type PluginBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Rejections> = {
+    lifecycle: 'before';
     from: ResolvedRoute | null;
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
@@ -37,6 +38,7 @@ type PluginBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Re
     abort: CallbackContextAbort;
 };
 type PluginAfterRouteHookContext<TRoutes extends Routes, TRejections extends Rejections> = {
+    lifecycle: 'after';
     from: ResolvedRoute | null;
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
@@ -44,12 +46,12 @@ type PluginAfterRouteHookContext<TRoutes extends Routes, TRejections extends Rej
 };
 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;
+type AddPluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = AddHook<PluginBeforeRouteLeaveHook<TRoutes, TRejections>>;
 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;
+type AddPluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = AddHook<PluginAfterRouteLeaveHook<TRoutes, TRejections>>;
 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;
+type AddPluginBeforeRouteHook<TRoutes extends Routes, TRejections extends Rejections> = AddHook<PluginBeforeRouteHook<TRoutes, TRejections>>;
+type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejections> = AddHook<PluginAfterRouteHook<TRoutes, TRejections>>;
 export type PluginErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     to: ResolvedRoute | null;
     from: ResolvedRoute | null;

package/dist/types/routerPush.d.ts

@@ -1,3 +1,4 @@
+import { NavigationBehavior } from './navigation';
 import { Routes } from './route';
 import { RoutesName } from './routesMap';
 import { RouteParamsByKey } from './routeWithParams';
@@ -6,6 +7,7 @@ import { UrlString } from './urlString';
 import { AllPropertiesAreOptional } from './utilities';
 import { QuerySource } from './querySource';
 import { ResolvedRoute } from './resolved';
+import { ViewTransitionConfig } from './viewTransition';
 export type RouterPushOptions<TState = unknown> = {
     /**
      * The query string to add to the url.
@@ -19,10 +21,16 @@ export type RouterPushOptions<TState = unknown> = {
      * Whether to replace the current history entry.
      */
     replace?: boolean;
+    /** Overrides the route and router navigation behavior. */
+    navigation?: NavigationBehavior;
     /**
      * State values to pass to the route.
      */
     state?: Partial<TState>;
+    /**
+     * Animates the navigation with the View Transitions API. Overrides route and router level viewTransition.
+     */
+    viewTransition?: ViewTransitionConfig;
 };
 type RouterPushArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>];
 export type RouterPush<TRoutes extends Routes = any> = {

package/dist/types/routerReplace.d.ts

@@ -1,3 +1,4 @@
+import { NavigationBehavior } from './navigation';
 import { Routes } from './route';
 import { RoutesName } from './routesMap';
 import { RouteParamsByKey } from './routeWithParams';
@@ -8,6 +9,8 @@ import { QuerySource } from './querySource';
 import { ResolvedRoute } from './resolved';
 export type RouterReplaceOptions<TState = unknown> = {
     query?: QuerySource;
+    /** Overrides the route and router navigation behavior. */
+    navigation?: NavigationBehavior;
     hash?: string;
     state?: Partial<TState>;
 };

package/dist/types/url.d.ts

@@ -9,6 +9,7 @@ export type UrlInternal = {
     [IS_URL_SYMBOL]: true;
     schema: Record<string, UrlPart>;
     params: {};
+    isMatch: (url: string, options?: ParseUrlOptions) => boolean;
 };
 export type CreateUrlOptions = {
     host?: string | UrlPart | undefined;