@kitbag/router 0.20.12 → 0.21.0

package/dist/types/callbackContext.d.ts

@@ -0,0 +1,15 @@
+import { RouterPush } from './routerPush';
+export type CallbackContextSuccess = {
+    status: 'SUCCESS';
+};
+export type CallbackContextPush = {
+    status: 'PUSH';
+    to: Parameters<RouterPush>;
+};
+export type CallbackContextReject = {
+    status: 'REJECT';
+    type: string;
+};
+export type CallbackContextAbort = {
+    status: 'ABORT';
+};

package/dist/types/createRouteOptions.d.ts

@@ -15,7 +15,6 @@ import { MaybePromise } from './utilities';
 import { ToMeta } from './meta';
 import { ToState } from './state';
 import { ToName } from './name';
-import { WithHooks } from './hooks';
 import { ToWithParams, WithParams } from '../services/withParams';
 import { RouteContext, ToRouteContext } from './routeContext';
 import { RouterViewProps } from '../components/routerView';
@@ -47,7 +46,7 @@ export declare function isWithComponents<T extends Record<string, unknown>>(opti
 export declare function isWithComponentPropsRecord<T extends Record<string, unknown>>(options: T): options is T & {
     props: RoutePropsRecord;
 };
-export type CreateRouteOptions<TName extends string | undefined = string | undefined, TPath extends string | WithParams | undefined = string | WithParams | undefined, TQuery extends string | WithParams | undefined = string | WithParams | undefined, THash extends string | WithParams | undefined = string | WithParams | undefined, TMeta extends RouteMeta = RouteMeta> = WithHooks & {
+export type CreateRouteOptions<TName extends string | undefined = string | undefined, TPath extends string | WithParams | undefined = string | WithParams | undefined, TQuery extends string | WithParams | undefined = string | WithParams | undefined, THash extends string | WithParams | undefined = string | WithParams | undefined, TMeta extends RouteMeta = RouteMeta> = {
     /**
      * Name for route, used to create route keys and in navigation.
      */
@@ -94,15 +93,9 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
      */
     context?: RouteContext[];
-    /**
-     * Props have been moved to the second argument of `createRoute`. This property can no longer be used.
-     *
-     * @deprecated
-     */
-    props?: never;
 };
-export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions>) => MaybePromise<ComponentProps<TComponent>>;
-export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
+export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<ComponentProps<TComponent>>;
+export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
 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]>;
@@ -121,13 +114,13 @@ type ToMatch<TOptions extends CreateRouteOptions, TProps extends CreateRouteProp
 type ToMatches<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = TOptions extends {
     parent: infer TParent extends Route;
 } ? [...TParent['matches'], ToMatch<TOptions, TProps>] : [ToMatch<TOptions, TProps>];
-export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = CreateRouteOptions extends TOptions ? Route : TOptions extends {
+export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined = undefined> = CreateRouteOptions extends TOptions ? Route : TOptions extends {
     parent: infer TParent extends Route;
-} ? Route<ToName<TOptions['name']>, ToWithParams<TParent['host']>, CombinePath<ToWithParams<TParent['path']>, ToWithParams<TOptions['path']>>, CombineQuery<ToWithParams<TParent['query']>, ToWithParams<TOptions['query']>>, CombineHash<ToWithParams<TParent['hash']>, ToWithParams<TOptions['hash']>>, CombineMeta<ToMeta<TParent['meta']>, ToMeta<TOptions['meta']>>, CombineState<ToState<TParent['state']>, ToState<TOptions['state']>>, ToMatches<TOptions, TProps>, [
+} ? Route<ToName<TOptions['name']>, ToWithParams<TParent['host']>, CombinePath<ToWithParams<TParent['path']>, ToWithParams<TOptions['path']>>, CombineQuery<ToWithParams<TParent['query']>, ToWithParams<TOptions['query']>>, CombineHash<ToWithParams<TParent['hash']>, ToWithParams<TOptions['hash']>>, CombineMeta<ToMeta<TParent['meta']>, ToMeta<TOptions['meta']>>, CombineState<ToState<TParent['state']>, ToState<TOptions['state']>>, ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>, [
     ...ToRouteContext<TParent['context']>,
     ...ToRouteContext<TOptions['context']>
 ]> : Route<ToName<TOptions['name']>, TOptions extends {
     host: string | WithParams;
-} ? ToWithParams<TOptions['host']> : WithParams<'', {}>, ToWithParams<TOptions['path']>, ToWithParams<TOptions['query']>, ToWithParams<TOptions['hash']>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, TProps>, ToRouteContext<TOptions['context']>>;
+} ? ToWithParams<TOptions['host']> : WithParams<'', {}>, ToWithParams<TOptions['path']>, ToWithParams<TOptions['query']>, ToWithParams<TOptions['hash']>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>, ToRouteContext<TOptions['context']>>;
 export declare function combineRoutes(parent: Route, child: Route): Route;
 export {};

package/dist/types/hooks.d.ts

@@ -1,201 +1,121 @@
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
-import { CallbackAbortResponse, CallbackContext, CallbackContextAbort, CallbackPushResponse, CallbackRejectResponse, CallbackSuccessResponse } from '../services/createCallbackContext';
+import { Hooks } from '../models/hooks';
 import { ResolvedRoute, RouterResolvedRouteUnion } from './resolved';
-import { MaybeArray, MaybePromise } from './utilities';
-import { Routes } from './route';
+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[] | undefined = undefined> = {
     /**
      * Registers a route hook to be called before the route is entered.
      */
-    onBeforeRouteEnter: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onBeforeRouteEnter: AddBeforeHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
     /**
      * Registers a route hook to be called before the route is left.
      */
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onBeforeRouteLeave: AddBeforeHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
     /**
      * Registers a route hook to be called before the route is updated.
      */
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onBeforeRouteUpdate: AddBeforeHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
     /**
      * Registers a route hook to be called after the route is entered.
      */
-    onAfterRouteEnter: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onAfterRouteEnter: AddAfterHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
     /**
      * Registers a route hook to be called after the route is left.
      */
-    onAfterRouteLeave: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onAfterRouteLeave: AddAfterHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
     /**
      * Registers a route hook to be called after the route is updated.
      */
-    onAfterRouteUpdate: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onAfterRouteUpdate: AddAfterHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
 };
-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;
+    onBeforeRouteEnter: AddBeforeHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
 };
-export type RouteHookAfterRunner = (context: AfterHookContext) => Promise<AfterRouteHookResponse>;
-export type RouteHookTiming = 'global' | 'component';
-type BeforeRouteHookRegistration<TRoutes extends Routes, TRejections extends Rejection[]> = {
+export type HookTiming = 'global' | 'component';
+type BeforeHookRegistration<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
     lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
-    hook: RouterBeforeRouteHook<TRoutes, TRejections>;
+    hook: BeforeHook<TRoute, 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[]> = {
+export type AddComponentBeforeHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: BeforeHookRegistration<TRoute, TRoutes, TRejections>) => HookRemove;
+type AfterHookRegistration<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
-    hook: RouterAfterRouteHook<TRoutes, TRejections>;
+    hook: AfterHook<TRoute, TRoutes, TRejections>;
     depth: number;
 };
-export type AddComponentAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: AfterRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
-export type AddGlobalRouteHooks = (hooks: RouterRouteHooks) => void;
-/**
- * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
- */
-type RouteHookContext = {
-    from: ResolvedRoute | null;
-    reject: CallbackContext['reject'];
-    push: CallbackContext['push'];
-    replace: CallbackContext['replace'];
-};
-/**
- * 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.
- */
-export type BeforeRouteHookContext = RouteHookContext & {
-    abort: CallbackContextAbort;
-};
-/**
- * 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;
+export type AddComponentAfterHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: AfterHookRegistration<TRoute, TRoutes, TRejections>) => HookRemove;
+export type AddGlobalHooks = (hooks: Hooks) => void;
 /**
- * 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.
+ * A function to remove a previously added route hook.
  */
-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.
- */
-export type AfterRouteHook = (to: ResolvedRoute, context: AfterRouteHookContext) => MaybePromise<void>;
-/**
- * Generic type representing a route hook, which can be either before or after a route change.
- */
-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[]> = {
+export type HookLifecycle = BeforeHookLifecycle | AfterHookLifecycle;
+type AfterHookContext<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
     from: RouterResolvedRouteUnion<TRoutes> | null;
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
+    update: RouteUpdate<ResolvedRoute<TRoute>>;
 };
-type RouterBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Rejection[]> = RouterHookContext<TRoutes, TRejections> & {
-    abort: CallbackContextAbort;
+type BeforeHookContext<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+    reject: RouterReject<TRejections>;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+    update: RouteUpdate<ResolvedRoute<TRoute>>;
+    abort: RouterAbort;
 };
-export type HookContext<TRoutes extends Routes = Routes> = {
+export type BeforeHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: RouterResolvedRouteUnion<TRoutes>, context: BeforeHookContext<TRoute, TRoutes, TRejections>) => MaybePromise<void>;
+export type AddBeforeHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: BeforeHook<TRoute, TRoutes, TRejections>) => HookRemove;
+export type AfterHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: RouterResolvedRouteUnion<TRoutes>, context: AfterHookContext<TRoute, TRoutes, TRejections>) => MaybePromise<void>;
+export type AddAfterHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: AfterHook<TRoute, TRoutes, TRejections>) => 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/params.d.ts

@@ -1,7 +1,6 @@
 import { LiteralParam, Param, ParamGetSet, ParamGetter } from './paramTypes';
 import { Identity } from './utilities';
-import { MakeOptional } from '../utilities/makeOptional';
-import { Route } from './route';
+import { MakeOptional, UnionToIntersection } from '../utilities/makeOptional';
 import { WithParams } from '../services/withParams';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 export declare const paramStart = "[";
@@ -32,19 +31,26 @@ export declare function isLiteralParam(value: Param): value is LiteralParam;
  * @returns The extracted parameter name, or never if the parameter string is empty.
  */
 export type ExtractParamName<TParam extends PropertyKey> = TParam extends string ? TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam : never;
+type ExtractWithParams<TParts extends Record<string, unknown>> = {
+    [K in keyof TParts as TParts[K] extends WithParams ? K : never]: TParts[K] extends WithParams ? TParts[K] : never;
+};
 /**
  * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
- * @template TRoute - The route type from which to extract and merge parameter types.
+ * @template Parts - The route from which to extract and merge parameter types.
  * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
  */
-export type ExtractRouteParamTypesReading<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesReading<TRoute['host']> & ExtractParamTypesReading<TRoute['path']> & ExtractParamTypesReading<TRoute['query']> & ExtractParamTypesReading<TRoute['hash']>>>;
+export type ExtractRouteParamTypesReading<TParts extends Record<PropertyKey, unknown>> = Identity<MakeOptional<UnionToIntersection<{
+    [K in keyof ExtractWithParams<TParts>]: ExtractParamTypesReading<ExtractWithParams<TParts>[K]>;
+}[keyof ExtractWithParams<TParts>]>>>;
 /**
  * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
  * Differs from ExtractRouteParamTypesReading in that optional params with defaults will remain optional.
  * @template TRoute - The route type from which to extract and merge parameter types.
  * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
  */
-export type ExtractRouteParamTypesWriting<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesWriting<TRoute['host']> & ExtractParamTypesWriting<TRoute['path']> & ExtractParamTypesWriting<TRoute['query']> & ExtractParamTypesWriting<TRoute['hash']>>>;
+export type ExtractRouteParamTypesWriting<TParts extends Record<string, unknown>> = Identity<MakeOptional<UnionToIntersection<{
+    [K in keyof ExtractWithParams<TParts>]: ExtractParamTypesWriting<ExtractWithParams<TParts>[K]>;
+}[keyof ExtractWithParams<TParts>]>>>;
 /**
  * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
  * @template TParams - The record of parameter types, possibly including undefined.

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/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,4 +1,4 @@
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { Hooks } from '../models/hooks';
 import { ExtractRouteParamTypesReading } from './params';
 import { Route, Routes } from './route';
 import { ExtractRouteStateParamsAsOptional } from './state';
@@ -50,7 +50,7 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      * 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

package/dist/types/route.d.ts

@@ -4,9 +4,9 @@ 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';
+import { Url } from '../main';
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
  */
@@ -14,7 +14,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,12 +79,13 @@ 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
     */
     depth: number;
+    assemble: (params: any) => Url;
 };
 export type GenericRoute = {
     id: string;

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 {};