@kitbag/router 0.20.12 → 0.22.0

package/dist/types/hooks.d.ts

@@ -1,201 +1,149 @@
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
-import { CallbackAbortResponse, CallbackContext, CallbackContextAbort, CallbackPushResponse, CallbackRejectResponse, CallbackSuccessResponse } from '../services/createCallbackContext';
-import { ResolvedRoute, RouterResolvedRouteUnion } from './resolved';
-import { MaybeArray, MaybePromise } from './utilities';
-import { Routes } from './route';
+import { Hooks } from '../models/hooks';
+import { ResolvedRoute, RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
+import { MaybePromise } from './utilities';
+import { Route, Routes } from './route';
 import { RouterReject } from './routerReject';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
-import { Rejection } from './rejection';
+import { Rejections } from './rejection';
 import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
-/**
- * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
- */
-export type WithHooks = {
-    /**
-     * @deprecated Use router.onBeforeRouteEnter instead
-     */
-    onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
-    /**
-     * @deprecated Use router.onBeforeRouteUpdate instead
-     */
-    onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
-    /**
-     * @deprecated Use router.onBeforeRouteLeave instead
-     */
-    onBeforeRouteLeave?: MaybeArray<BeforeRouteHook>;
-    /**
-     * @deprecated Use router.onAfterRouteEnter instead
-     */
-    onAfterRouteEnter?: MaybeArray<AfterRouteHook>;
-    /**
-     * @deprecated Use router.onAfterRouteUpdate instead
-     */
-    onAfterRouteUpdate?: MaybeArray<AfterRouteHook>;
-    /**
-     * @deprecated Use router.onAfterRouteLeave instead
-     */
-    onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
-};
-export type InternalRouteHooks<TContext extends RouteContext[] | undefined = undefined> = {
+import { RouterAbort } from './routerAbort';
+import { CallbackContextAbort, CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from './callbackContext';
+import { RouteUpdate } from './routeUpdate';
+export type InternalRouteHooks<TRoute extends Route = Route, TContext extends RouteContext[] = []> = {
     /**
      * Registers a route hook to be called before the route is entered.
      */
-    onBeforeRouteEnter: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onBeforeRouteEnter: AddBeforeEnterHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
     /**
      * Registers a route hook to be called before the route is left.
      */
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onBeforeRouteLeave: AddBeforeLeaveHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, Route, TRoute>;
     /**
      * Registers a route hook to be called before the route is updated.
      */
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onBeforeRouteUpdate: AddBeforeUpdateHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
     /**
      * Registers a route hook to be called after the route is entered.
      */
-    onAfterRouteEnter: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onAfterRouteEnter: AddAfterEnterHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
     /**
      * Registers a route hook to be called after the route is left.
      */
-    onAfterRouteLeave: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onAfterRouteLeave: AddAfterLeaveHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, Route, TRoute>;
     /**
      * Registers a route hook to be called after the route is updated.
      */
-    onAfterRouteUpdate: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onAfterRouteUpdate: AddAfterUpdateHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
 };
-export type ExternalRouteHooks<TContext extends RouteContext[] | undefined = undefined> = {
+export type ExternalRouteHooks<TRoute extends Route = Route, TContext extends RouteContext[] | undefined = undefined> = {
     /**
      * Registers a route hook to be called before the route is entered.
      */
-    onBeforeRouteEnter: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
-};
-export type BeforeHookContext = {
-    to: ResolvedRoute;
-    from: ResolvedRoute | null;
-};
-export type RouteHookBeforeRunner = (context: BeforeHookContext) => Promise<BeforeRouteHookResponse>;
-export type AfterHookContext = {
-    to: ResolvedRoute;
-    from: ResolvedRoute | null;
-};
-export type RouteHookAfterRunner = (context: AfterHookContext) => Promise<AfterRouteHookResponse>;
-export type RouteHookTiming = 'global' | 'component';
-type BeforeRouteHookRegistration<TRoutes extends Routes, TRejections extends Rejection[]> = {
-    lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
-    hook: RouterBeforeRouteHook<TRoutes, TRejections>;
-    depth: number;
-};
-export type AddComponentBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: BeforeRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
-type AfterRouteHookRegistration<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
-    lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
-    hook: RouterAfterRouteHook<TRoutes, TRejections>;
-    depth: number;
+    onBeforeRouteEnter: AddBeforeEnterHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
 };
-export type AddComponentAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: AfterRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
-export type AddGlobalRouteHooks = (hooks: RouterRouteHooks) => void;
+export type HookTiming = 'global' | 'component';
 /**
- * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
+ * Union type for all component route hooks.
  */
-type RouteHookContext = {
-    from: ResolvedRoute | null;
-    reject: CallbackContext['reject'];
-    push: CallbackContext['push'];
-    replace: CallbackContext['replace'];
-};
+export type ComponentHook = BeforeEnterHook | BeforeUpdateHook | BeforeLeaveHook | AfterEnterHook | AfterUpdateHook | AfterLeaveHook;
 /**
- * Context provided to route hooks, containing context of previous route and functions for triggering rejections, push/replace to another route,
- * as well as aborting current route change.
+ * Registration object for adding a component route hook.
  */
-export type BeforeRouteHookContext = RouteHookContext & {
-    abort: CallbackContextAbort;
+export type ComponentHookRegistration = {
+    lifecycle: HookLifecycle;
+    hook: ComponentHook;
+    depth: number;
 };
 /**
- * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
- */
-export type AfterRouteHookContext = RouteHookContext;
-/**
- * Represents a function called before a route change, potentially altering the routing operation.
- * @param to - {@link ResolvedRoute} The resolved route the router is navigating to.
- * @param context - {@link BeforeRouteHookContext} The context providing functions and state for the routing operation.
- * @returns Possibly a promise that resolves when the hook's logic has completed.
- */
-export type BeforeRouteHook = (to: ResolvedRoute, context: BeforeRouteHookContext) => MaybePromise<void>;
-/**
- * Represents a function called after a route change has occurred.
- * @param to - {@link ResolvedRoute} The resolved route the router has navigated to.
- * @param context - {@link AfterRouteHookContext} The context providing functions and state for the routing operation.
- * @returns Possibly a promise that resolves when the hook's logic has completed.
+ * Function to add a component route hook with depth-based condition checking.
  */
-export type AfterRouteHook = (to: ResolvedRoute, context: AfterRouteHookContext) => MaybePromise<void>;
+export type AddComponentHook = (registration: ComponentHookRegistration) => HookRemove;
+export type AddGlobalHooks = (hooks: Hooks) => void;
 /**
- * Generic type representing a route hook, which can be either before or after a route change.
+ * A function to remove a previously added route hook.
  */
-export type RouteHook = BeforeRouteHook | AfterRouteHook;
-/**
- * A function to remove a previously registered route hook.
- */
-export type RouteHookRemove = () => void;
+export type HookRemove = () => void;
 /**
  * Enumerates the lifecycle events for before route hooks.
  */
-export type BeforeRouteHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
+export type BeforeHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
 /**
  * Enumerates the lifecycle events for after route hooks.
  */
-export type AfterRouteHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
+export type AfterHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
 /**
  * Union type for all route hook lifecycle events.
  */
-export type RouteHookLifecycle = BeforeRouteHookLifecycle | AfterRouteHookLifecycle;
-/**
- * Type for responses from a before route hook, which may indicate different outcomes such as success, push, reject, or abort.
- * @template TRoutes - The type of the routes configuration.
- */
-export type BeforeRouteHookResponse = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse | CallbackAbortResponse;
-/**
- * Type for responses from an after route hook, which may indicate different outcomes such as success, push, or reject.
- * @template TRoutes - The type of the routes configuration.
- */
-export type AfterRouteHookResponse = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse;
-/**
- * Union type for all possible route hook responses, covering both before and after scenarios.
- * @template TRoutes - The type of the routes configuration.
- */
-export type RouteHookResponse = BeforeRouteHookResponse | AfterRouteHookResponse;
-type RouterHookContext<TRoutes extends Routes, TRejections extends Rejection[]> = {
-    from: RouterResolvedRouteUnion<TRoutes> | null;
+export type HookLifecycle = BeforeHookLifecycle | AfterHookLifecycle;
+type AfterHookContext<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
+    update: RouteUpdate<ResolvedRouteUnion<TRoute>>;
 };
-type RouterBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Rejection[]> = RouterHookContext<TRoutes, TRejections> & {
-    abort: CallbackContextAbort;
+type BeforeHookContext<TRouteTo extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
+    reject: RouterReject<TRejections>;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+    update: RouteUpdate<ResolvedRouteUnion<TRouteTo>>;
+    abort: RouterAbort;
+};
+export type BeforeEnterHookContext<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 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 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 BeforeLeaveHookContext<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>;
 };
-export type HookContext<TRoutes extends Routes = Routes> = {
+export type BeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, 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 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 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 AfterLeaveHookContext<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>;
+};
+export type AfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, 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 BeforeHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject | CallbackContextAbort;
+export type AfterHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject;
+export type BeforeHookRunner = <TRoutes extends Routes>(context: {
     to: RouterResolvedRouteUnion<TRoutes>;
     from: RouterResolvedRouteUnion<TRoutes> | null;
-};
-export type RouterBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
-export type AddRouterBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: RouterBeforeRouteHook<TRoutes, TRejections>) => RouteHookRemove;
-type RouterAfterRouteHookContext<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = RouterHookContext<TRoutes, TRejections>;
-export type RouterAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
-export type AddRouterAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: RouterAfterRouteHook<TRoutes, TRejections>) => RouteHookRemove;
-export type RouterRouteHookBeforeRunner = (context: HookContext) => Promise<BeforeRouteHookResponse>;
-export type RouterRouteHookAfterRunner = (context: HookContext) => Promise<AfterRouteHookResponse>;
-export type RouterErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+}) => Promise<BeforeHookResponse>;
+export type AfterHookRunner = <TRoutes extends Routes>(context: {
+    to: RouterResolvedRouteUnion<TRoutes>;
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+}) => Promise<AfterHookResponse>;
+export type ErrorHookContext<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     to: RouterResolvedRouteUnion<TRoutes>;
     from: RouterResolvedRouteUnion<TRoutes> | null;
     source: 'props' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
+    update: RouteUpdate<ResolvedRoute<TRoute>>;
 };
-export type RouterErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (error: unknown, context: RouterErrorHookContext<TRoutes, TRejections>) => void;
-export type AddRouterErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: RouterErrorHook<TRoutes, TRejections>) => RouteHookRemove;
-export type RouterRouteHookErrorRunnerContext<TRoutes extends Routes = Routes> = {
+export type ErrorHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (error: unknown, context: ErrorHookContext<TRoute, TRoutes, TRejections>) => void;
+export type AddErrorHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: ErrorHook<TRoute, TRoutes, TRejections>) => HookRemove;
+export type ErrorHookRunnerContext<TRoutes extends Routes = Routes> = {
     to: RouterResolvedRouteUnion<TRoutes>;
     from: RouterResolvedRouteUnion<TRoutes> | null;
     source: 'props' | 'hook';
 };
-export type RouterRouteHookErrorRunner = (error: unknown, context: RouterRouteHookErrorRunnerContext) => void;
+export type ErrorHookRunner = (error: unknown, context: ErrorHookRunnerContext) => void;
 export {};

package/dist/types/props.d.ts

@@ -3,19 +3,19 @@ import { Route } from './route';
 import { RouterReject } from './routerReject';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
-import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { ExtractRouteContextRejections, ExtractRouteContextRoutes } from './routeContext';
+import { ResolvedRoute } from './resolved';
+import { RouteUpdate } from './routeUpdate';
 /**
  * Context provided to props callback functions
  */
-export type PropsCallbackContext<TOptions extends CreateRouteOptions = CreateRouteOptions> = {
-    reject: RouterReject<RouteContextToRejection<ExtractRouteContext<TOptions>>>;
-    push: RouterPush<RouteContextToRoute<ExtractRouteContext<TOptions>>>;
-    replace: RouterReplace<RouteContextToRoute<ExtractRouteContext<TOptions>>>;
+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>>;
     parent: PropsCallbackParent<TOptions['parent']>;
 };
-type ExtractRouteContext<TOptions extends CreateRouteOptions> = TOptions extends {
-    context: infer TContext extends RouteContext[];
-} ? TContext : [];
 export type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
     name: string;
     props: unknown;

package/dist/types/redirects.d.ts

@@ -0,0 +1,40 @@
+import { ExtractRouteParamTypesReading, ExtractRouteParamTypesWriting } from './params';
+import { ResolvedRouteUnion } from './resolved';
+import { Route, Routes } from './route';
+import { RouterReplace } from './routerReplace';
+import { AllPropertiesAreOptional, MaybePromise } from './utilities';
+/**
+ * redirect is returned by createRouteHooks but is not part of the Route type, so we use this type to assert that it exists.
+ */
+type RouteWithRedirect<TRoute extends Route = Route> = TRoute & {
+    redirect: RouteRedirect;
+};
+/**
+ * Type guard to assert that a route has a redirect hook.
+ * @internal
+ */
+export declare function isRouteWithRedirect(route: Route): route is RouteWithRedirect;
+export type RouteRedirects<TRoute extends Route = Route> = {
+    /**
+     * Creates a redirect to redirect the current route to another route.
+     */
+    redirectTo: RouteRedirectTo<TRoute>;
+    /**
+     * Creates a redirect to redirect to the current route from another route.
+     */
+    redirectFrom: RouteRedirectFrom<TRoute>;
+};
+type RedirectHookContext<TRoutes extends Routes> = {
+    replace: RouterReplace<TRoutes>;
+};
+export type RedirectHook<TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: RedirectHookContext<TRoutes>) => MaybePromise<void>;
+export type RouteRedirectCallback<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = (params: ExtractRouteParamTypesReading<TRouteFrom>) => ExtractRouteParamTypesWriting<TRouteTo>;
+/**
+ * This type is purposely wide to prevent type errors in RouteRedirectFrom where the TRouteTo generic cannot be inferred.
+ */
+export type RouteRedirect = (to: Route, callback?: (params: any) => any) => void;
+export type RedirectToArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<ExtractRouteParamTypesWriting<TRouteTo>> extends true ? [to: TRouteTo, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>] : [to: TRouteTo, params: RouteRedirectCallback<TRouteTo, TRouteFrom>];
+export type RouteRedirectTo<TRouteFrom extends Route = Route> = <TRouteTo extends Route>(...args: RedirectToArgs<TRouteTo, TRouteFrom>) => void;
+export type RedirectFromArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<ExtractRouteParamTypesWriting<TRouteTo>> extends true ? [from: TRouteFrom, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>] : [from: TRouteFrom, params: RouteRedirectCallback<TRouteTo, TRouteFrom>];
+export type RouteRedirectFrom<TRouteTo extends Route = Route> = <TRouteFrom extends Route>(...args: RedirectFromArgs<TRouteTo, TRouteFrom>) => void;
+export {};

package/dist/types/register.d.ts

@@ -1,10 +1,4 @@
-import { BuiltInRejectionType } from '../services/createRouterReject';
-import { Route, Routes } from './route';
-import { Router, RouterOptions } from './router';
-import { RouterPush } from './routerPush';
-import { RouterReplace } from './routerReplace';
-import { RoutesName } from './routesMap';
-import { RejectionType } from './rejection';
+import { Router } from './router';
 /**
  * Represents the state of currently registered router, and route meta. Used to provide correct type context for
  * components like `RouterLink`, as well as for composables like `useRouter`, `useRoute`, and hooks.
@@ -27,43 +21,9 @@ export interface Register {
 export type RegisteredRouter<T = Register> = T extends {
     router: infer TRouter;
 } ? TRouter : Router;
-/**
- * Represents the Router routes property within {@link Register}
- * @deprecated will be removed in a future version
- */
-export type RegisteredRoutes<T = Register> = T extends {
-    router: Router<infer TRoutes extends Routes>;
-} ? TRoutes : Route[];
-/**
- * Represents the possible Rejections registered within {@link Register}
- * @deprecated use `createRouter(..., { rejections: {}}) instead
- */
-export type RegisteredRejectionType<T = Register> = T extends {
-    router: Router<any, infer TOptions extends RouterOptions>;
-} ? RejectionType<TOptions['rejections']> | BuiltInRejectionType : BuiltInRejectionType;
 /**
  * Represents additional metadata associated with a route, customizable via declaration merging.
  */
 export type RouteMeta<T = Register> = T extends {
     routeMeta: infer RouteMeta extends Record<string, unknown>;
 } ? RouteMeta : Record<string, unknown>;
-/**
- * Represents the type for router `push`, with types for routes registered within {@link Register}
- * @deprecated will be removed in a future version
- */
-export type RegisteredRouterPush = RouterPush<RegisteredRoutes>;
-/**
- * Represents the type for router `replace`, with types for routes registered within {@link Register}
- * @deprecated will be removed in a future version
- */
-export type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
-/**
- * Type for Router Reject method. Triggers rejections registered within {@link Register}
- * @deprecated will be removed in a future version
- */
-export type RegisteredRouterReject = (type: RegisteredRejectionType) => void;
-/**
- * Represents the union of all possible route names registered within {@link Register}
- * @deprecated will be removed in a future version
- */
-export type RegisteredRoutesName = RoutesName<RegisteredRoutes>;

package/dist/types/rejection.d.ts

@@ -1,4 +1,8 @@
 import { Component } from 'vue';
+/**
+ * Represents an immutable array of Rejection instances.
+ */
+export type Rejections = readonly Rejection[];
 export type Rejection<TType extends string = string> = {
     /**
      * The type of rejection.
@@ -9,7 +13,7 @@ export type Rejection<TType extends string = string> = {
      */
     component: Component;
 };
-export type RejectionType<TRejections extends Rejection[] | undefined> = unknown extends TRejections ? never : Rejection[] extends TRejections ? string : undefined extends TRejections ? string : TRejections extends Rejection[] ? TRejections[number]['type'] : never;
+export type RejectionType<TRejections extends Rejections | undefined> = unknown extends TRejections ? never : Rejections extends TRejections ? string : undefined extends TRejections ? string : TRejections extends Rejections ? TRejections[number]['type'] : never;
 export type ExtractRejections<T> = T extends {
-    rejections: infer TRejections extends Rejection[];
+    rejections: infer TRejections extends Rejections;
 } ? TRejections : [];

package/dist/types/resolved.d.ts

@@ -1,8 +1,8 @@
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { Hooks } from '../models/hooks';
 import { ExtractRouteParamTypesReading } from './params';
 import { Route, Routes } from './route';
 import { ExtractRouteStateParamsAsOptional } from './state';
-import { Url } from './url';
+import { UrlString } from './urlString';
 /**
  * Represents a route that the router has matched to current browser location.
  * @template TRoute - Underlying Route that has been resolved.
@@ -44,13 +44,13 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
     /**
      * String value of the resolved URL.
      */
-    href: Url;
+    href: UrlString;
     /**
      * The stores for routes including ancestors.
      * Order of routes will be from greatest ancestor to narrowest matched.
      * @internal
      */
-    hooks: RouterRouteHooks[];
+    hooks: Hooks[];
 }>;
 /**
  * This type is the same as `ResolvedRoute<TRoutes[number]>` while remaining distributive
@@ -58,3 +58,13 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
 export type RouterResolvedRouteUnion<TRoutes extends Routes> = {
     [K in keyof TRoutes]: ResolvedRoute<TRoutes[K]>;
 }[number];
+/**
+ * Converts a union of Route types to a union of ResolvedRoute types while preserving the discriminated union structure for narrowing.
+ * This is useful when you have a Route union (like `TRoutes[number]`) and need it to narrow properly.
+ * Uses a distributive conditional type to ensure unions are properly distributed.
+ *
+ * @example
+ * type RouteUnion = RouteA | RouteB
+ * type ResolvedUnion = ResolvedRouteUnion<RouteUnion> // ResolvedRoute<RouteA> | ResolvedRoute<RouteB>
+ */
+export type ResolvedRouteUnion<TRoute extends Route> = TRoute extends Route ? ResolvedRoute<TRoute> : never;

package/dist/types/route.d.ts

@@ -4,9 +4,8 @@ import { PrefetchConfig } from './prefetch';
 import { RouteMeta } from './register';
 import { LastInArray } from './utilities';
 import { CreateRouteOptions } from './createRouteOptions';
-import { WithHooks } from './hooks';
 import { RouteContext } from './routeContext';
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { Hooks } from '../models/hooks';
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
  */
@@ -14,7 +13,7 @@ export type Routes = readonly Route[];
 /**
  * The Route properties originally provided to `createRoute`. The only change is normalizing meta to always default to an empty object.
  */
-export type CreatedRouteOptions = Omit<CreateRouteOptions, 'props'> & WithHooks & {
+export type CreatedRouteOptions = Omit<CreateRouteOptions, 'props'> & {
     id: string;
     props?: unknown;
 };
@@ -79,7 +78,7 @@ export type Route<TName extends string = string, THost extends WithParams = With
      * Order of routes will be from greatest ancestor to narrowest matched.
      * @internal
      */
-    hooks: RouterRouteHooks[];
+    hooks: Hooks[];
     /**
     * A value that represents how many parents a route has. Used for route matching
     * @internal

package/dist/types/routeContext.d.ts

@@ -1,9 +1,15 @@
-import { Rejection } from './rejection';
-import { GenericRoute, Route } from './route';
+import { CreateRouteOptions } from './createRouteOptions';
+import { Rejection, Rejections } from './rejection';
+import { GenericRoute, Routes } from './route';
 export type RouteContext = GenericRoute | Rejection;
-export type ToRouteContext<TContext extends RouteContext[] | undefined> = TContext extends RouteContext[] ? TContext : [];
-export type RouteContextToRoute<TContext extends RouteContext[] | undefined> = RouteContext[] extends TContext ? Route[] : undefined extends TContext ? Route[] : FilterRouteContextRoutes<TContext>;
+export type ToRouteContext<TContext extends RouteContext[] | readonly RouteContext[] | undefined> = TContext extends RouteContext[] ? TContext : [];
+export type ExtractRouteContext<TOptions extends CreateRouteOptions> = TOptions extends {
+    context: infer TContext extends RouteContext[];
+} ? TContext : [];
+export type ExtractRouteContextRoutes<TOptions extends CreateRouteOptions> = RouteContextToRoute<ExtractRouteContext<TOptions>>;
+export type ExtractRouteContextRejections<TOptions extends CreateRouteOptions> = RouteContextToRejection<ExtractRouteContext<TOptions>>;
+export type RouteContextToRoute<TContext extends RouteContext[] | undefined> = RouteContext[] extends TContext ? Routes : undefined extends TContext ? Routes : FilterRouteContextRoutes<TContext>;
 type FilterRouteContextRoutes<TContext extends RouteContext[] | undefined> = TContext extends [infer First, ...infer Rest extends RouteContext[]] ? First extends GenericRoute ? [First, ...FilterRouteContextRoutes<Rest>] : FilterRouteContextRoutes<Rest> : [];
-export type RouteContextToRejection<TContext extends RouteContext[] | undefined> = RouteContext[] extends TContext ? Rejection[] : undefined extends TContext ? Rejection[] : FilterRouteContextRejections<TContext>;
+export type RouteContextToRejection<TContext extends RouteContext[] | undefined> = RouteContext[] extends TContext ? Rejections : undefined extends TContext ? Rejections : FilterRouteContextRejections<TContext>;
 type FilterRouteContextRejections<TContext extends RouteContext[] | undefined> = TContext extends [infer First, ...infer Rest extends RouteContext[]] ? First extends Rejection ? [First, ...FilterRouteContextRejections<Rest>] : FilterRouteContextRejections<Rest> : [];
 export {};

package/dist/types/router.d.ts

@@ -1,7 +1,7 @@
 import { App, InjectionKey, Ref } from 'vue';
 import { RouterHistoryMode } from '../services/createRouterHistory';
 import { RouterRoute } from './routerRoute';
-import { AddRouterAfterRouteHook, AddRouterBeforeRouteHook, AddRouterErrorHook, WithHooks } from './hooks';
+import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook } from './hooks';
 import { PrefetchConfig } from './prefetch';
 import { ResolvedRoute } from './resolved';
 import { Route, Routes } from './route';
@@ -12,11 +12,11 @@ import { RouterReject } from './routerReject';
 import { RouterPlugin } from './routerPlugin';
 import { RoutesName } from './routesMap';
 import { ToRouteContext } from './routeContext';
-import { ExtractRejections, Rejection } from './rejection';
+import { ExtractRejections, Rejections } from './rejection';
 /**
  * Options to initialize a {@link Router} instance.
  */
-export type RouterOptions = WithHooks & {
+export type RouterOptions = {
     /**
      * Initial URL for the router to use. Required if using Node environment. Defaults to window.location when using browser.
      *
@@ -41,7 +41,7 @@ export type RouterOptions = WithHooks & {
     /**
      * Components assigned to each type of rejection your router supports.
      */
-    rejections?: Rejection[];
+    rejections?: Rejections;
     /**
      * When false, createRouterAssets must be used for component and hooks. Assets exported by the library
      * will not work with the created router instance.
@@ -99,32 +99,32 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
     /**
      * Registers a hook to be called before a route is entered.
      */
-    onBeforeRouteEnter: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onBeforeRouteEnter: AddBeforeEnterHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called before a route is left.
      */
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onBeforeRouteLeave: AddBeforeLeaveHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called before a route is updated.
      */
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onBeforeRouteUpdate: AddBeforeUpdateHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is entered.
      */
-    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onAfterRouteEnter: AddAfterEnterHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is left.
      */
-    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onAfterRouteLeave: AddAfterLeaveHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is updated.
      */
-    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onAfterRouteUpdate: AddAfterUpdateHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called when an error occurs.
      * If the hook returns true, the error is considered handled and the other hooks are not run. If all hooks return false the error is rethrown
      */
-    onError: AddRouterErrorHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
+    onError: AddErrorHook<TRoutes[number] | TPlugin['routes'][number], TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
     * Given a URL, returns true if host does not match host stored on router instance
     */
@@ -151,6 +151,11 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      * @private
      */
     key: InjectionKey<Router<TRoutes, TOptions, TPlugin>>;
+    /**
+     * Returns true if the router's devtools plugin has been installed
+     * @private
+     */
+    hasDevtools: boolean;
 };
 /**
  * This type is the same as `RouterRoute<ResolvedRoute<TRoutes[number]>>` while remaining distributive

package/dist/types/routerAbort.d.ts

@@ -0,0 +1 @@
+export type RouterAbort = () => void;