@kitbag/router 0.21.0 → 0.22.0

package/dist/services/createRouterAssets.d.ts

@@ -7,7 +7,7 @@ import { createUseRouter } from '../compositions/useRouter';
 import { createUseQueryValue } from '../compositions/useQueryValue';
 import { createUseLink } from '../compositions/useLink';
 import { createIsRoute } from '../guards/routes';
-import { AddAfterHook, AddBeforeHook } from '../types/hooks';
+import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../types/hooks';
 export type RouterAssets<TRouter extends Router> = {
     /**
      * Registers a hook that is called before a route is left. Must be called from setup.
@@ -17,7 +17,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onBeforeRouteLeave: AddBeforeHook<RouterRoutes<TRouter>[number], RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onBeforeRouteLeave: AddBeforeLeaveHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * Registers a hook that is called before a route is updated. Must be called from setup.
      * This is particularly useful for handling changes in route parameters or query while staying within the same component.
@@ -26,7 +26,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onBeforeRouteUpdate: AddBeforeHook<RouterRoutes<TRouter>[number], RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onBeforeRouteUpdate: AddBeforeUpdateHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * Registers a hook that is called after a route has been left. Must be called during setup.
      * This can be used for cleanup actions after the component is no longer active, ensuring proper resource management.
@@ -35,7 +35,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onAfterRouteLeave: AddAfterHook<RouterRoutes<TRouter>[number], RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onAfterRouteLeave: AddAfterLeaveHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * Registers a hook that is called after a route has been updated. Must be called during setup.
      * This is ideal for responding to updates within the same route, such as parameter changes, without full component reloads.
@@ -44,7 +44,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onAfterRouteUpdate: AddAfterHook<RouterRoutes<TRouter>[number], RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onAfterRouteUpdate: AddAfterUpdateHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * A guard to verify if a route or unknown value matches a given route name.
      *

package/dist/services/createRouterHooks.d.ts

@@ -1,19 +1,18 @@
-import { AddGlobalHooks, AddComponentAfterHook, AddComponentBeforeHook, AfterHookRunner, BeforeHookRunner, AddBeforeHook, AddAfterHook, ErrorHookRunner, AddErrorHook } from '../types/hooks';
+import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook } from '../types/hooks';
 import { HasVueAppStore } from './createVueAppStore';
 export declare const getRouterHooksKey: (routerKey: import('vue').InjectionKey<import('../main').Router>) => import('vue').InjectionKey<RouterHooks>;
 export type RouterHooks = HasVueAppStore & {
     runBeforeRouteHooks: BeforeHookRunner;
     runAfterRouteHooks: AfterHookRunner;
     runErrorHooks: ErrorHookRunner;
-    addComponentBeforeRouteHook: AddComponentBeforeHook;
-    addComponentAfterRouteHook: AddComponentAfterHook;
+    addComponentHook: AddComponentHook;
     addGlobalRouteHooks: AddGlobalHooks;
-    onBeforeRouteEnter: AddBeforeHook;
-    onBeforeRouteUpdate: AddBeforeHook;
-    onBeforeRouteLeave: AddBeforeHook;
-    onAfterRouteEnter: AddAfterHook;
-    onAfterRouteUpdate: AddAfterHook;
-    onAfterRouteLeave: AddAfterHook;
+    onBeforeRouteEnter: AddBeforeEnterHook;
+    onBeforeRouteUpdate: AddBeforeUpdateHook;
+    onBeforeRouteLeave: AddBeforeLeaveHook;
+    onAfterRouteEnter: AddAfterEnterHook;
+    onAfterRouteUpdate: AddAfterUpdateHook;
+    onAfterRouteLeave: AddAfterLeaveHook;
     onError: AddErrorHook;
 };
 export declare function createRouterHooks(): RouterHooks;

package/dist/services/insertBaseRoute.d.ts

@@ -1,2 +1,2 @@
-import { Routes } from '../types/route';
-export declare function insertBaseRoute(routes: Routes, base?: string): Routes;
+import { Route } from '../types/route';
+export declare function insertBaseRoute(route: Route, base?: string): Route;

package/dist/services/routeMatchRules.d.ts

@@ -1,5 +1,4 @@
 import { RouteMatchRule } from '../types/routeMatchRule';
-export declare const isNamedRoute: RouteMatchRule;
 export declare const routeHostMatches: RouteMatchRule;
 export declare const routePathMatches: RouteMatchRule;
 export declare const routeQueryMatches: RouteMatchRule;

package/dist/services/routeMatchScore.d.ts

@@ -3,5 +3,5 @@ import { QuerySource } from '../types/querySource';
 type RouteSortMethod = (aRoute: Route, bRoute: Route) => number;
 export declare function getRouteScoreSortMethod(url: string): RouteSortMethod;
 export declare function countExpectedPathParams(route: Route, actualPath: string): number;
-export declare function countExpectedQueryParams(route: Route, actual: QuerySource): number;
+export declare function countExpectedQueryParams(route: Route, actualQuery: QuerySource): number;
 export {};

package/dist/services/routeRegex.d.ts

@@ -3,6 +3,7 @@ import { WithParams } from './withParams';
 export declare function splitByMatches(string: string, regexp: RegExp): string[];
 export declare function generateRouteHostRegexPattern(route: Route): RegExp;
 export declare function generateRoutePathRegexPattern(route: Route): RegExp;
+export declare function generateRouteHashRegexPattern(route: Route): RegExp;
 export declare function generateRouteQueryRegexPatterns(route: Route): RegExp[];
 export declare function replaceParamSyntaxWithCatchAlls(value: string): string;
 export declare function replaceIndividualParamWithCaptureGroup(path: string, paramName: string): string;

package/dist/services/urlAssembly.d.ts

@@ -1,10 +1,10 @@
 import { Route } from '../types/route';
-import { Url } from '../types/url';
+import { UrlString } from '../types/urlString';
 import { QuerySource } from '../types/querySource';
 type AssembleUrlOptions = {
     params?: Record<string, unknown>;
     query?: QuerySource;
     hash?: string;
 };
-export declare function assembleUrl(route: Route, options?: AssembleUrlOptions): Url;
+export declare function assembleUrl(route: Route, options?: AssembleUrlOptions): UrlString;
 export {};

package/dist/services/urlCombine.d.ts

@@ -1,3 +1,2 @@
-import { Url } from '../types/url';
-import { UrlParts } from '../types/urlParts';
-export declare function combineUrl(previous: Url | Partial<UrlParts>, updated: Url | Partial<UrlParts>): Url;
+import { UrlString, UrlParts } from '../types/urlString';
+export declare function combineUrl(previous: UrlString | Partial<UrlParts>, updated: UrlString | Partial<UrlParts>): UrlString;

package/dist/services/urlCreator.d.ts

@@ -1,3 +1,2 @@
-import { Url } from '../types/url';
-import { UrlParts } from '../types/urlParts';
-export declare function createUrl({ protocol, host, pathname, search, searchParams, hash }: Partial<UrlParts>): Url;
+import { UrlString, UrlParts } from '../types/urlString';
+export declare function createUrl({ protocol, host, pathname, search, searchParams, hash }: Partial<UrlParts>): UrlString;

package/dist/services/urlParser.d.ts

@@ -1,2 +1,2 @@
-import { UrlParts } from '../types/urlParts';
+import { UrlParts } from '../types/urlString';
 export declare function parseUrl(value: string): UrlParts;

package/dist/types/hooks.d.ts

@@ -1,5 +1,5 @@
 import { Hooks } from '../models/hooks';
-import { ResolvedRoute, RouterResolvedRouteUnion } from './resolved';
+import { ResolvedRoute, RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
 import { MaybePromise } from './utilities';
 import { Route, Routes } from './route';
 import { RouterReject } from './routerReject';
@@ -10,51 +10,55 @@ import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './ro
 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> = {
+export type InternalRouteHooks<TRoute extends Route = Route, TContext extends RouteContext[] = []> = {
     /**
      * Registers a route hook to be called before the route is entered.
      */
-    onBeforeRouteEnter: AddBeforeHook<TRoute, [TRoute] | 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: AddBeforeHook<TRoute, [TRoute] | 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: AddBeforeHook<TRoute, [TRoute] | 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: AddAfterHook<TRoute, [TRoute] | 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: AddAfterHook<TRoute, [TRoute] | 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: AddAfterHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onAfterRouteUpdate: AddAfterUpdateHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
 };
 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: AddBeforeHook<TRoute, [TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    onBeforeRouteEnter: AddBeforeEnterHook<[TRoute] | RouteContextToRoute<TContext>, RouteContextToRejection<TContext>, TRoute, Route>;
 };
 export type HookTiming = 'global' | 'component';
-type BeforeHookRegistration<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
-    lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
-    hook: BeforeHook<TRoute, TRoutes, TRejections>;
-    depth: number;
-};
-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: AfterHook<TRoute, TRoutes, TRejections>;
+/**
+ * Union type for all component route hooks.
+ */
+export type ComponentHook = BeforeEnterHook | BeforeUpdateHook | BeforeLeaveHook | AfterEnterHook | AfterUpdateHook | AfterLeaveHook;
+/**
+ * Registration object for adding a component route hook.
+ */
+export type ComponentHookRegistration = {
+    lifecycle: HookLifecycle;
+    hook: ComponentHook;
     depth: number;
 };
-export type AddComponentAfterHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: AfterHookRegistration<TRoute, TRoutes, TRejections>) => HookRemove;
+/**
+ * Function to add a component route hook with depth-based condition checking.
+ */
+export type AddComponentHook = (registration: ComponentHookRegistration) => HookRemove;
 export type AddGlobalHooks = (hooks: Hooks) => void;
 /**
  * A function to remove a previously added route hook.
@@ -73,24 +77,48 @@ export type AfterHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'o
  */
 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>>;
+    update: RouteUpdate<ResolvedRouteUnion<TRoute>>;
 };
-type BeforeHookContext<TRoute extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
-    from: RouterResolvedRouteUnion<TRoutes> | null;
+type BeforeHookContext<TRouteTo extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
-    update: RouteUpdate<ResolvedRoute<TRoute>>;
+    update: RouteUpdate<ResolvedRouteUnion<TRouteTo>>;
     abort: RouterAbort;
 };
-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 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 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: {

package/dist/types/params.d.ts

@@ -1,6 +1,7 @@
 import { LiteralParam, Param, ParamGetSet, ParamGetter } from './paramTypes';
 import { Identity } from './utilities';
-import { MakeOptional, UnionToIntersection } from '../utilities/makeOptional';
+import { MakeOptional } from '../utilities/makeOptional';
+import { Route } from './route';
 import { WithParams } from '../services/withParams';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 export declare const paramStart = "[";
@@ -31,26 +32,19 @@ 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 Parts - The route from which to extract and merge parameter types.
+ * @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 ExtractRouteParamTypesReading<TParts extends Record<PropertyKey, unknown>> = Identity<MakeOptional<UnionToIntersection<{
-    [K in keyof ExtractWithParams<TParts>]: ExtractParamTypesReading<ExtractWithParams<TParts>[K]>;
-}[keyof ExtractWithParams<TParts>]>>>;
+export type ExtractRouteParamTypesReading<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesReading<TRoute['host']> & ExtractParamTypesReading<TRoute['path']> & ExtractParamTypesReading<TRoute['query']> & ExtractParamTypesReading<TRoute['hash']>>>;
 /**
  * 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<TParts extends Record<string, unknown>> = Identity<MakeOptional<UnionToIntersection<{
-    [K in keyof ExtractWithParams<TParts>]: ExtractParamTypesWriting<ExtractWithParams<TParts>[K]>;
-}[keyof ExtractWithParams<TParts>]>>>;
+export type ExtractRouteParamTypesWriting<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesWriting<TRoute['host']> & ExtractParamTypesWriting<TRoute['path']> & ExtractParamTypesWriting<TRoute['query']> & ExtractParamTypesWriting<TRoute['hash']>>>;
 /**
  * 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/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/resolved.d.ts

@@ -2,7 +2,7 @@ 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,7 +44,7 @@ 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.
@@ -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

@@ -6,7 +6,6 @@ import { LastInArray } from './utilities';
 import { CreateRouteOptions } from './createRouteOptions';
 import { RouteContext } from './routeContext';
 import { Hooks } from '../models/hooks';
-import { Url } from '../main';
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
  */
@@ -85,7 +84,6 @@ export type Route<TName extends string = string, THost extends WithParams = With
     * @internal
     */
     depth: number;
-    assemble: (params: any) => Url;
 };
 export type GenericRoute = {
     id: string;

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 { AddAfterHook, AddBeforeHook, AddErrorHook } 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';
@@ -99,27 +99,27 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
     /**
      * Registers a hook to be called before a route is entered.
      */
-    onBeforeRouteEnter: AddBeforeHook<TRoutes[number] | TPlugin['routes'][number], 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: AddBeforeHook<TRoutes[number] | TPlugin['routes'][number], 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: AddBeforeHook<TRoutes[number] | TPlugin['routes'][number], 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: AddAfterHook<TRoutes[number] | TPlugin['routes'][number], 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: AddAfterHook<TRoutes[number] | TPlugin['routes'][number], 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: AddAfterHook<TRoutes[number] | TPlugin['routes'][number], 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
@@ -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/routerLink.d.ts

@@ -1,14 +1,14 @@
 import { PrefetchConfig } from './prefetch';
-import { Url } from './url';
+import { UrlString } from './urlString';
 import { ResolvedRoute } from './resolved';
 import { Router } from './router';
 import { RouterPushOptions } from './routerPush';
-export type ToCallback<TRouter extends Router> = (resolve: TRouter['resolve']) => ResolvedRoute | Url | undefined;
+export type ToCallback<TRouter extends Router> = (resolve: TRouter['resolve']) => ResolvedRoute | UrlString | undefined;
 export type RouterLinkProps<TRouter extends Router> = RouterPushOptions & {
     /**
      * The url string to navigate to or a callback that returns a url string
      */
-    to: Url | ResolvedRoute | ToCallback<TRouter>;
+    to: UrlString | ResolvedRoute | ToCallback<TRouter>;
     /**
      * Determines what assets are prefetched when router-link is rendered for this route. Overrides route level prefetch.
      */

package/dist/types/routerPush.d.ts

@@ -2,7 +2,7 @@ import { Routes } from './route';
 import { RoutesName } from './routesMap';
 import { RouteParamsByKey } from './routeWithParams';
 import { RouteStateByName } from './state';
-import { Url } from './url';
+import { UrlString } from './urlString';
 import { AllPropertiesAreOptional } from './utilities';
 import { QuerySource } from './querySource';
 import { ResolvedRoute } from './resolved';
@@ -28,6 +28,6 @@ type RouterPushArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>>
 export type RouterPush<TRoutes extends Routes = any> = {
     <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterPushArgs<TRoutes, TSource>): Promise<void>;
     (route: ResolvedRoute, options?: RouterPushOptions): Promise<void>;
-    (url: Url, options?: RouterPushOptions): Promise<void>;
+    (url: UrlString, options?: RouterPushOptions): Promise<void>;
 };
 export {};

package/dist/types/routerReplace.d.ts

@@ -2,7 +2,7 @@ import { Routes } from './route';
 import { RoutesName } from './routesMap';
 import { RouteParamsByKey } from './routeWithParams';
 import { RouteStateByName } from './state';
-import { Url } from './url';
+import { UrlString } from './urlString';
 import { AllPropertiesAreOptional } from './utilities';
 import { QuerySource } from './querySource';
 import { ResolvedRoute } from './resolved';
@@ -15,6 +15,6 @@ type RouterReplaceArgs<TRoutes extends Routes, TSource extends RoutesName<TRoute
 export type RouterReplace<TRoutes extends Routes> = {
     <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
     (route: ResolvedRoute, options?: RouterReplaceOptions): Promise<void>;
-    (url: Url, options?: RouterReplaceOptions): Promise<void>;
+    (url: UrlString, options?: RouterReplaceOptions): Promise<void>;
 };
 export {};

package/dist/types/urlString.d.ts

@@ -0,0 +1,23 @@
+import { QuerySource } from './querySource';
+export type UrlString = `http://${string}` | `https://${string}` | `/${string}`;
+export type UrlParts = {
+    protocol?: string;
+    host?: string;
+    pathname: string;
+    searchParams: QuerySource;
+    search: string;
+    hash: string;
+};
+/**
+ * A type guard for determining if a value is a valid URL.
+ * @param value - The value to check.
+ * @returns `true` if the value is a valid URL, otherwise `false`.
+ * @group Type Guards
+ */
+export declare function isUrlString(value: unknown): value is UrlString;
+/**
+ * Converts a string to a valid URL.
+ * @param value - The string to convert.
+ * @returns The valid URL.
+ */
+export declare function asUrlString(value: string): UrlString;

package/dist/types/useLink.d.ts

@@ -3,7 +3,7 @@ import { PrefetchConfig } from './prefetch';
 import { ResolvedRoute } from './resolved';
 import { RouterPushOptions } from './routerPush';
 import { RouterReplaceOptions } from './routerReplace';
-import { Url } from './url';
+import { UrlString } from './urlString';
 export type UseLink = {
     /**
      * A template ref to bind to the dom for automatic prefetching
@@ -16,7 +16,7 @@ export type UseLink = {
     /**
      * Resolved URL with params interpolated and query applied. Same value as `router.resolve`.
      */
-    href: ComputedRef<Url | undefined>;
+    href: ComputedRef<UrlString | undefined>;
     /**
      * True if route matches current URL or is ancestor of route that matches current URL
      */

package/dist/utilities/checkDuplicateParams.spec.d.ts

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

package/dist/utilities/index.d.ts

@@ -1,5 +1,5 @@
 export * from './array';
-export * from './checkDuplicateKeys';
+export * from './checkDuplicateParams';
 export * from './guards';
 export * from './isBrowser';
 export * from './makeOptional';

package/dist/utilities/isNamedRoute.d.ts

@@ -0,0 +1,4 @@
+import { Route } from '../types/route';
+export declare function isNamedRoute(route: Route): route is Route & {
+    name: string;
+};

package/dist/utilities/makeOptional.d.ts

@@ -6,5 +6,4 @@ export type MakeOptional<T> = {
 } & {
     [P in Exclude<keyof T, WithOptionalProperties<T>>]: T[P];
 };
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 export {};