@kitbag/router 0.28.0 → 0.29.0

package/dist/main.d.ts

@@ -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';
@@ -46,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';
@@ -61,6 +64,18 @@ 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.

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/addView.d.ts

@@ -3,6 +3,8 @@ import { AnyPayloadTransformer } from './payload';
 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.
@@ -16,25 +18,26 @@ type ViewOptions = {
 /**
  * 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: AddViewPropsGetter<Route, Component> | 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/createRouterAssets.d.ts

@@ -1,3 +1,6 @@
+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';
@@ -14,6 +17,18 @@ 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.

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

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

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/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/registerHookContext.spec.d.ts

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

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/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,4 +1,6 @@
 import { Component } from 'vue';
+import { AnyView } from './view';
+import { RouteContext, WithRouteContext } from './routeContext';
 import { ComponentProps } from '../services/component';
 import { ResolvedRoute, WithData } from './resolved';
 import { CreatedRouteOptions, Route } from './route';
@@ -83,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.
@@ -103,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 {};

package/dist/types/createRouteOptions.d.ts

@@ -66,7 +66,7 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      */
     parent?: Route;
     /**
-     * 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[];
     /**
@@ -95,15 +95,11 @@ type ToMatch<TOptions extends CreateRouteOptions> = Omit<TOptions, 'meta' | 'nam
  * 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> = TOptions extends {
-    parent: infer TParent extends Route;
-} ? [...TParent['matches'], ToMatch<TOptions>] : [ToMatch<TOptions>];
+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> : CombineUrl<TParent, ToUrl<TOptions>> : ToUrl<TOptions>;
+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, before any views or loaders are added.
  */

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;