@kitbag/router 0.7.1 → 0.7.2

package/README.md

@@ -100,7 +100,7 @@ const settings = createRoute({
 
 const router = useRouter([user, profile, settings])
 
-router.push('user.settings')
+router.push('settings')
 ```
 
 The push method also accepts a plain string if you know the URL you want to go to.
@@ -110,7 +110,7 @@ router.push('/user/settings')
 router.push('https://github.com/kitbagjs/router')
 ```
 
-This `source` argument is type safe, expecting either a Url or a valid route "key". Url is any string that starts with "http", "https", or a forward slash "/". Route key is a string of route names joined by a period `.`. Additionally if using the route key, push will require params be passed in if there are any.
+This `source` argument is type safe, expecting either a [`Url`](/api/types/Url) or a valid route [`name`](/api/types/Route#name). URL is any string that starts with "http", "https", or a forward slash "/". Additionally if using the route name, push will require params be passed in if there are any.
 
 ## Update
 

package/dist/kitbag-router.d.ts

@@ -121,8 +121,6 @@ declare const builtInRejections: ['NotFound'];
 
 declare type BuiltInRejectionType = typeof builtInRejections[number];
 
-declare type CombineKey<TParentKey extends string | undefined, TChildKey extends string | undefined> = StringHasValue<TParentKey> extends true ? StringHasValue<TChildKey> extends true ? `${TParentKey}.${TChildKey}` : TParentKey : StringHasValue<TChildKey> extends true ? TChildKey : '';
-
 declare type CombineMeta<TParent extends Record<string, unknown>, TChild extends Record<string, unknown>> = TParent & TChild;
 
 declare type CombinePath<TParent extends Path, TChild extends Path> = ToPath<TParent> extends {
@@ -171,9 +169,9 @@ declare type ComponentPropsGetter<TComponent extends Component> = () => MaybePro
 
 declare type Constructor = new (...args: any) => any;
 
-export declare function createExternalRoute<const THost extends string | Host, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined>(options: CreateRouteOptions<TName, TPath, TQuery> & WithHost<THost> & WithoutParent): Route<ToKey<TName>, ToHost<THost>, ToPath<TPath>, ToQuery<TQuery>>;
+export declare function createExternalRoute<const THost extends string | Host, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined>(options: CreateRouteOptions<TName, TPath, TQuery> & WithHost<THost> & WithoutParent): Route<ToName<TName>, ToHost<THost>, ToPath<TPath>, ToQuery<TQuery>>;
 
-export declare function createExternalRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined>(options: CreateRouteOptions<TName, TPath, TQuery> & WithoutHost & WithParent<TParent>): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>>;
+export declare function createExternalRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined>(options: CreateRouteOptions<TName, TPath, TQuery> & WithoutHost & WithParent<TParent>): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>>;
 
 export declare function createParam<TParam extends ParamWithDefault>(param: TParam): TParam;
 
@@ -181,17 +179,17 @@ export declare function createParam<TParam extends Param>(param: TParam): ParamG
 
 export declare function createParam<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;
 
-export declare function createRoute<const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithoutComponents & WithoutParent & (WithState<TState> | WithoutState)): Route<ToKey<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, TMeta, TState>;
+export declare function createRoute<const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithoutComponents & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, TMeta, TState>;
 
-export declare function createRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithoutComponents & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
+export declare function createRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithoutComponents & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
 
-export declare function createRoute<TComponent extends Component, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToKey<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, TMeta, TState>;
+export declare function createRoute<TComponent extends Component, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, TMeta, TState>;
 
-export declare function createRoute<TComponent extends Component, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
+export declare function createRoute<TComponent extends Component, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
 
-export declare function createRoute<TComponents extends Record<string, Component>, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToKey<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, TMeta, TState>;
+export declare function createRoute<TComponents extends Record<string, Component>, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, TMeta, TState>;
 
-export declare function createRoute<TComponents extends Record<string, Component>, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
+export declare function createRoute<TComponents extends Record<string, Component>, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
 
 export declare type CreateRouteOptions<TName extends string | undefined = string | undefined, TPath extends string | Path | undefined = string | Path | undefined, TQuery extends string | Query | undefined = string | Query | undefined, TMeta extends RouteMeta = RouteMeta> = {
     /**
@@ -247,8 +245,8 @@ export declare function createRouter<const T extends Routes>(routes: T, options?
 export declare function createRouter<const T extends Routes>(arrayOfRoutes: T[], options?: RouterOptions): Router<T>;
 
 /**
- * An error thrown when duplicate parameters are detected in a route when creating a router.
- * When defining routes, param names must be unique. This includes params defined in a path
+ * An error thrown when duplicate parameters are detected in a route.
+ * Param names must be unique. This includes params defined in a path
  * parent and params defined in the query.
  */
 export declare class DuplicateParamsError extends Error {
@@ -367,33 +365,33 @@ export declare function isParamWithDefault(param: Param): param is ParamWithDefa
 
 export declare function isRoute(route: unknown): route is RouterRoute;
 
-export declare function isRoute<TRoute extends RouterRoute, TRouteKey extends TRoute['key']>(route: TRoute, routeKey: TRouteKey, options: IsRouteOptions & {
+export declare function isRoute<TRoute extends RouterRoute, TRouteName extends TRoute['name']>(route: TRoute, routeName: TRouteName, options: IsRouteOptions & {
     exact: true;
 }): route is TRoute & {
-    key: TRouteKey;
+    name: TRouteName;
 };
 
-export declare function isRoute<TRoute extends RouterRoute, TRouteKey extends TRoute['key']>(route: TRoute, routeKey: TRouteKey, options?: IsRouteOptions): route is TRoute & {
-    key: `${TRouteKey}${string}`;
+export declare function isRoute<TRoute extends RouterRoute, TRouteName extends TRoute['name']>(route: TRoute, routeName: TRouteName, options?: IsRouteOptions): route is TRoute & {
+    name: `${TRouteName}${string}`;
 };
 
-export declare function isRoute<TRouteKey extends RegisteredRoutesKey>(route: unknown, routeKey: TRouteKey, options: IsRouteOptions & {
+export declare function isRoute<TRouteName extends RegisteredRoutesName>(route: unknown, routeName: TRouteName, options: IsRouteOptions & {
     exact: true;
 }): route is RegisteredRouterRoute & {
-    key: TRouteKey;
+    name: TRouteName;
 };
 
-export declare function isRoute<TRouteKey extends RegisteredRoutesKey>(route: unknown, routeKey: TRouteKey, options?: IsRouteOptions): route is RegisteredRouterRoute & {
-    key: `${TRouteKey}${string}`;
+export declare function isRoute<TRouteName extends RegisteredRoutesName>(route: unknown, routeName: TRouteName, options?: IsRouteOptions): route is RegisteredRouterRoute & {
+    name: `${TRouteName}${string}`;
 };
 
-export declare function isRoute(route: unknown, routeKey?: string, options?: IsRouteOptions): boolean;
+export declare function isRoute(route: unknown, routeName?: string, options?: IsRouteOptions): boolean;
 
 declare type IsRouteOptions = {
     exact?: boolean;
 };
 
-declare type IsRouteUnnamed<T extends Route> = StringHasValue<T['key']> extends true ? false : true;
+declare type IsRouteUnnamed<T extends Route> = StringHasValue<T['name']> extends true ? false : true;
 
 declare type MakeOptional<T> = {
     [P in WithOptionalProperties<T>]?: T[P];
@@ -576,7 +574,7 @@ export declare type RegisteredRejectionType = Register extends {
 } ? TRejections[number] : never;
 
 /**
- * Represents the a map of all possible RouteKeys with corresponding Route registered within {@link Register}
+ * Represents the a map of all possible route names with corresponding Route registered within {@link Register}
  */
 export declare type RegisteredRouteMap = RoutesMap<RegisteredRoutes>;
 
@@ -610,9 +608,9 @@ export declare type RegisteredRoutes = Register extends {
 } ? TRoutes : Route[];
 
 /**
- * Represents the union of all possible RouteKeys registered within {@link Register}
+ * Represents the union of all possible route names registered within {@link Register}
  */
-export declare type RegisteredRoutesKey = RoutesKey<RegisteredRoutes>;
+export declare type RegisteredRoutesName = RoutesName<RegisteredRoutes>;
 
 declare type RemoveLeadingQuestionMark<T extends PropertyKey> = T extends `?${infer TRest extends string}` ? TRest : T;
 
@@ -635,9 +633,9 @@ declare type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      */
     matches: TRoute['matches'];
     /**
-     * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
+     * Unique identifier for the route. Name is used for routing and for matching.
      */
-    key: TRoute['key'];
+    name: TRoute['name'];
     /**
      * Accessor for query string values from user in the current browser location.
      */
@@ -659,11 +657,11 @@ declare type ResolvedRouteQuery = {
 
 /**
  * Represents the structure of a route within the application. Return value of `createRoute`
- * @template TKey - Represents the unique key identifying the route, typically a string.
+ * @template TName - Represents the unique name identifying the route, typically a string.
  * @template TPath - The type or structure of the route's path.
  * @template TQuery - The type or structure of the query parameters associated with the route.
  */
-export declare type Route<TKey extends string = string, THost extends Host = Host, TPath extends Path = Path, TQuery extends Query = Query, TMeta extends RouteMeta = RouteMeta, TState extends Record<string, Param> = Record<string, Param>> = {
+export declare type Route<TName extends string = string, THost extends Host = Host, TPath extends Path = Path, TQuery extends Query = Query, TMeta extends RouteMeta = RouteMeta, TState extends Record<string, Param> = Record<string, Param>> = {
     /**
      * The specific route properties that were matched in the current route.
      */
@@ -674,9 +672,9 @@ export declare type Route<TKey extends string = string, THost extends Host = Hos
      */
     matches: CreateRouteOptionsMatched[];
     /**
-     * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
+     * Unique identifier for the route. Name is used for routing and for matching.
      */
-    key: TKey;
+    name: TName;
     /**
      * Represents the host for this route. Used for external routes.
      */
@@ -700,7 +698,7 @@ export declare type Route<TKey extends string = string, THost extends Host = Hos
     depth: number;
 };
 
-declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesKey<TRoutes>> = RoutesMap<TRoutes>[TKey];
+declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesName<TRoutes>> = RoutesMap<TRoutes>[TKey];
 
 /**
  * Generic type representing a route hook, which can be either before or after a route change.
@@ -856,11 +854,11 @@ export declare type Router<TRoutes extends Routes = any> = Plugin_2 & {
 };
 
 declare type RouterFind<TRoutes extends Routes> = {
-    <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterFindArgs<TRoutes, TSource>): ResolvedRoute | undefined;
-    (source: Url): ResolvedRoute | undefined;
+    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterFindArgs<TRoutes, TSource>): ResolvedRoute | undefined;
+    (url: Url): ResolvedRoute | undefined;
 };
 
-declare type RouterFindArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams] : [params: TParams];
+declare type RouterFindArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams] : [params: TParams];
 
 declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
 
@@ -917,11 +915,11 @@ export declare type RouterOptions = {
 } & RouterRejectionComponents;
 
 declare type RouterPush<TRoutes extends Routes = any> = {
-    <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterPushArgs<TRoutes, TSource>): Promise<void>;
-    (source: Url, options?: RouterPushOptions): Promise<void>;
+    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterPushArgs<TRoutes, TSource>): Promise<void>;
+    (url: Url, options?: RouterPushOptions): Promise<void>;
 };
 
-declare type RouterPushArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByKey<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByKey<TRoutes, TSource>>];
+declare type RouterPushArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>];
 
 declare type RouterPushOptions<TState = unknown> = {
     query?: Record<string, string>;
@@ -945,11 +943,11 @@ export declare const routerRejectionKey: InjectionKey<RouterRejection>;
 declare type RouterRejectionType = BuiltInRejectionType | RegisteredRejectionType;
 
 declare type RouterReplace<TRoutes extends Routes> = {
-    <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
-    (source: Url, options?: RouterReplaceOptions): Promise<void>;
+    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
+    (url: Url, options?: RouterReplaceOptions): Promise<void>;
 };
 
-declare type RouterReplaceArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterReplaceOptions<RouteStateByKey<TRoutes, TSource>>] : [params: TParams, options?: RouterReplaceOptions<RouteStateByKey<TRoutes, TSource>>];
+declare type RouterReplaceArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterReplaceOptions<RouteStateByName<TRoutes, TSource>>] : [params: TParams, options?: RouterReplaceOptions<RouteStateByName<TRoutes, TSource>>];
 
 declare type RouterReplaceOptions<TState = unknown> = {
     query?: Record<string, string>;
@@ -957,18 +955,18 @@ declare type RouterReplaceOptions<TState = unknown> = {
 };
 
 declare type RouterResolve<TRoutes extends Routes> = {
-    <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterResolveArgs<TRoutes, TSource>): string;
-    (source: Url, options?: RouterResolveOptions): string;
+    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterResolveArgs<TRoutes, TSource>): string;
+    (url: Url, options?: RouterResolveOptions): string;
 };
 
-declare type RouterResolveArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterResolveOptions] : [params: TParams, options?: RouterResolveOptions];
+declare type RouterResolveArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterResolveOptions] : [params: TParams, options?: RouterResolveOptions];
 
 declare type RouterResolveOptions = {
     query?: Record<string, string>;
 };
 
 declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Readonly<{
-    key: TRoute['key'];
+    name: TRoute['name'];
     matched: TRoute['matched'];
     matches: TRoute['matches'];
     state: TRoute['state'];
@@ -991,7 +989,7 @@ name?: string | undefined;
 }>>>, {}, {}>, Readonly<{
     default?: ((props: {
         route: Readonly<{
-            key: string;
+            name: string;
             matched: CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithoutComponents | WithComponent | WithComponents) & (WithoutParent | WithParent) & (WithoutState | WithState) & {
                 meta: Record<string, unknown>;
             };
@@ -1008,7 +1006,7 @@ name?: string | undefined;
             [x: number]: any;
             }>;
             update: {
-                (key: string, value: unknown, options?: RouterPushOptions | undefined): Promise<void>;
+                (paramName: string, paramValue: unknown, options?: RouterPushOptions | undefined): Promise<void>;
                 (params: Partial<{
                     [x: string]: any;
                     [x: number]: any;
@@ -1026,7 +1024,7 @@ name?: string | undefined;
 }> & {
     default?: ((props: {
         route: Readonly<{
-            key: string;
+            name: string;
             matched: CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithoutComponents | WithComponent | WithComponents) & (WithoutParent | WithParent) & (WithoutState | WithState) & {
                 meta: Record<string, unknown>;
             };
@@ -1043,7 +1041,7 @@ name?: string | undefined;
             [x: number]: any;
             }>;
             update: {
-                (key: string, value: unknown, options?: RouterPushOptions | undefined): Promise<void>;
+                (paramName: string, paramValue: unknown, options?: RouterPushOptions | undefined): Promise<void>;
                 (params: Partial<{
                     [x: string]: any;
                     [x: number]: any;
@@ -1065,19 +1063,19 @@ name?: string | undefined;
  */
 export declare type Routes = Readonly<Route[]>;
 
-declare type RoutesKey<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
-
 declare type RoutesMap<TRoutes extends Routes = []> = {
-    [K in TRoutes[number] as AsNamedRoute<K>['key']]: AsNamedRoute<K>;
+    [K in TRoutes[number] as AsNamedRoute<K>['name']]: AsNamedRoute<K>;
 };
 
-declare type RouteStateByKey<TRoutes extends Routes, TKey extends string> = ExtractStateParams<RouteGetByKey<TRoutes, TKey>>;
+declare type RoutesName<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
+
+declare type RouteStateByName<TRoutes extends Routes, TName extends string> = ExtractStateParams<RouteGetByKey<TRoutes, TName>>;
 
 declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = ResolvedRoute extends TRoute ? {
-    (key: string, value: unknown, options?: RouterPushOptions): Promise<void>;
+    (paramName: string, paramValue: unknown, options?: RouterPushOptions): Promise<void>;
     (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
 } : {
-    <TKey extends keyof TRoute['params']>(key: TKey, value: TRoute['params'][TKey], options?: RouterPushOptions): Promise<void>;
+    <TParamName extends keyof TRoute['params']>(paramName: TParamName, paramValue: TRoute['params'][TParamName], options?: RouterPushOptions): Promise<void>;
     (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
 };
 
@@ -1087,7 +1085,7 @@ declare type ToCallback = (resolve: RegisteredRouter['resolve']) => string;
 
 declare type ToHost<T extends string | Host | undefined> = T extends string ? Host<T, {}> : T extends undefined ? Host<'', {}> : unknown extends T ? Host<'', {}> : T;
 
-declare type ToKey<T extends string | undefined> = T extends string ? T : '';
+declare type ToName<T extends string | undefined> = T extends string ? T : '';
 
 declare type ToPath<T extends string | Path | undefined> = T extends string ? Path<T, {}> : T extends undefined ? Path<'', {}> : unknown extends T ? Path<'', {}> : T;
 
@@ -1127,17 +1125,17 @@ export declare type UseLink = {
  * or resolved URL to discover route details. Also exports some useful context about routes relationship to current URL and convenience methods
  * for navigating.
  *
- * @param source - The key of the route or the URL value.
- * @param params - If providing route key, this argument will expect corresponding params.
+ * @param source - The name of the route or the URL value.
+ * @param params - If providing route name, this argument will expect corresponding params.
  * @param options - {@link RouterResolveOptions}Same options as router resolve.
  * @returns {UseLink} Reactive context values for as well as navigation methods.
  *
  */
-export declare function useLink<TRouteKey extends RegisteredRoutesKey>(routeKey: MaybeRefOrGetter<TRouteKey>, ...args: UseLinkArgs<TRouteKey>): UseLink;
+export declare function useLink<TRouteKey extends RegisteredRoutesName>(name: MaybeRefOrGetter<TRouteKey>, ...args: UseLinkArgs<TRouteKey>): UseLink;
 
 export declare function useLink(url: MaybeRefOrGetter<Url>): UseLink;
 
-declare type UseLinkArgs<TSource extends RegisteredRoutesKey, TParams = RouteParamsByKey<RegisteredRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>] : [params: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>];
+declare type UseLinkArgs<TSource extends RegisteredRoutesName, TParams = RouteParamsByKey<RegisteredRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>] : [params: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>];
 
 /**
  * A composition to access the router's rejection state.
@@ -1150,29 +1148,29 @@ declare type UseLinkArgs<TSource extends RegisteredRoutesKey, TParams = RoutePar
 export declare function useRejection(): RouterRejection;
 
 /**
- * A composition to access the current route or verify a specific route key within a Vue component.
+ * A composition to access the current route or verify a specific route name within a Vue component.
  * This function provides two overloads:
  * 1. When called without arguments, it returns the current route from the router without types.
- * 2. When called with a route key, it checks if the current active route includes the specified route key.
+ * 2. When called with a route name, it checks if the current active route includes the specified route name.
  *
- * @template TRouteKey - A string type that should match route key of RegisteredRouteMap, ensuring the route key exists.
- * @param routeKey - Optional. The key of the route to validate against the current active routes.
- * @returns The current router route. If a route key is provided, it validates the route key first.
- * @throws {UseRouteInvalidError} Throws an error if the provided route key is not valid or does not match the current route.
+ * @template TRouteName - A string type that should match route name of RegisteredRouteMap, ensuring the route name exists.
+ * @param routeName - Optional. The name of the route to validate against the current active routes.
+ * @returns The current router route. If a route name is provided, it validates the route name first.
+ * @throws {UseRouteInvalidError} Throws an error if the provided route name is not valid or does not match the current route.
  *
- * The function also sets up a reactive watcher on the route object from the router to continually check the validity of the route key
+ * The function also sets up a reactive watcher on the route object from the router to continually check the validity of the route name
  * if provided, throwing an error if the validation fails at any point during the component's lifecycle.
  */
 export declare function useRoute(): RegisteredRouterRoute;
 
-export declare function useRoute<TRouteKey extends RegisteredRoutesKey>(routeKey: TRouteKey, options: IsRouteOptions & {
+export declare function useRoute<TRouteName extends RegisteredRoutesName>(routeName: TRouteName, options: IsRouteOptions & {
     exact: true;
 }): RegisteredRouterRoute & {
-    key: TRouteKey;
+    name: TRouteName;
 };
 
-export declare function useRoute<TRouteKey extends RegisteredRoutesKey>(routeKey: TRouteKey, options?: IsRouteOptions): RegisteredRouterRoute & {
-    key: `${TRouteKey}${string}`;
+export declare function useRoute<TRouteName extends RegisteredRoutesName>(routeName: TRouteName, options?: IsRouteOptions): RegisteredRouterRoute & {
+    name: `${TRouteName}${string}`;
 };
 
 /**