@kitbag/router 0.26.1 → 0.28.0

package/dist/types/addAlias.d.ts

@@ -0,0 +1,79 @@
+import { UrlPart, UrlQueryPart } from '../services/withParams';
+import { AliasTransform } from './routeAlias';
+import { CreatedRouteOptions } from './route';
+import { RouteWithMethods } from './routeWithMethods';
+import { ToUrl, Url, UrlParamsReading, UrlParamsWriting } from './url';
+import { LastInArray } from './utilities';
+/**
+ * The url an alias matches, in the same shapes `createRoute` takes. An alias declares its whole url:
+ * nothing is taken from the route's own path, query, or hash.
+ */
+export type AddAliasOptions = {
+    /**
+     * Path part of the alias.
+     */
+    path?: string | UrlPart | undefined;
+    /**
+     * Query (aka search) part of the alias.
+     */
+    query?: string | UrlQueryPart | undefined;
+    /**
+     * Hash part of the alias.
+     */
+    hash?: string | UrlPart | undefined;
+};
+type PathPart = string | UrlPart | undefined;
+type QueryPart = string | UrlQueryPart | undefined;
+type SegmentPath<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    path: infer TPath extends PathPart;
+} ? TPath : undefined;
+type SegmentQuery<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    query: infer TQuery extends QueryPart;
+} ? TQuery : undefined;
+type SegmentHash<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    hash: infer THash extends PathPart;
+} ? THash : undefined;
+/**
+ * The url of the route's own segment: its own path, query, and hash without any ancestors. An alias
+ * stands in for this segment, so its params are what an alias transform has to produce.
+ */
+type SegmentUrl<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? Url : ToUrl<{
+    path: SegmentPath<TMatches>;
+    query: SegmentQuery<TMatches>;
+    hash: SegmentHash<TMatches>;
+}>;
+/**
+ * The params an alias parses from a url, as read.
+ */
+type AliasParams<TOptions extends AddAliasOptions> = UrlParamsReading<ToUrl<TOptions>>;
+/**
+ * The params the route's own segment declares, as written. What an alias transform returns.
+ */
+type SegmentParams<TMatches extends CreatedRouteOptions[]> = UrlParamsWriting<SegmentUrl<TMatches>>;
+/**
+ * The transform argument for `addAlias`. Optional only when the alias's params already satisfy the
+ * segment's, since matched values pass straight through then. A shape mismatch has to be resolved at
+ * declaration time: parsing walks the params declared on the pattern doing the parsing, so a mismatch
+ * would silently read a promised param as undefined instead of failing.
+ */
+type AddAliasArgs<TOptions extends AddAliasOptions, TMatches extends CreatedRouteOptions[]> = AliasParams<TOptions> extends SegmentParams<TMatches> ? [transform?: AliasTransform<AliasParams<TOptions>, SegmentParams<TMatches>>] : [transform: AliasTransform<AliasParams<TOptions>, SegmentParams<TMatches>>];
+/**
+ * Adds an alias to a route. Chainable to register several.
+ */
+export type RouteAddAlias<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = {
+    /**
+     * Adds a url the route also matches. The address bar keeps the alias; the route resolves as if its own
+     * url had matched. Aliases only match inbound urls: links and navigation always target the route's own
+     * url.
+     *
+     * The alias stands in for this route's own path, query, and hash, and composes with any aliases of the
+     * route's ancestors. It declares its own params, typed the same way a route's are, and any param the
+     * route's own segment declares that the alias does not is the transform's to supply.
+     *
+     * @param options - The alias's `path`, `query`, and `hash`, each taking what `createRoute` does.
+     * @param transform - Maps the alias's params into the params this route's own segment declares.
+     * Required unless the alias's params already satisfy them.
+     */
+    addAlias: <const TOptions extends AddAliasOptions>(options: TOptions, ...args: AddAliasArgs<TOptions, TMatches>) => RouteWithMethods<TUrl, TMatches>;
+};
+export {};

package/dist/types/addView.d.ts

@@ -1,6 +1,5 @@
 import { Component } from 'vue';
 import { ComponentProps } from '../services/component';
-import { ComponentPropsAreOptional, PropsGetter } from './createRouteOptions';
 import { ResolvedRoute, WithData } from './resolved';
 import { CreatedRouteOptions, Route } from './route';
 import { RouteCallbackContext } from './routeCallbackContext';
@@ -11,8 +10,7 @@ import { RouteView, RouteViews } from './routeViews';
 import { Url } from './url';
 import { AnyFunction, Identity, LastInArray, MaybePromise } from './utilities';
 /**
- * The props getter for a view added via `addView`. Receives the same two arguments as the
- * `createRoute` props callback: the resolved route and a context object.
+ * The props getter for a view added via `addView`. Receives the resolved route and a context object.
  */
 export type AddViewPropsGetter<TRoute extends Route, TComponent extends Component> = (route: ResolvedRoute<TRoute> & WithData<TRoute>, context: AddViewPropsCallbackContext<TRoute>) => MaybePromise<ComponentProps<TComponent>>;
 /**
@@ -20,6 +18,7 @@ export type AddViewPropsGetter<TRoute extends Route, TComponent extends Componen
  * callbacks attached to a route.
  */
 export type AddViewPropsCallbackContext<TRoute extends Route> = RouteCallbackContext<TRoute>;
+type ComponentPropsAreOptional<TComponent extends Component> = Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? true : false;
 /**
  * When the getter is omitted the default type param resolves to the wide getter type, which then
  * "extends" itself and collapses to undefined. When a getter is provided its return type is kept — the
@@ -32,7 +31,7 @@ type NewViewProps<TRoute extends Route, TComponent extends Component, TGetter ex
  * @template TName - The view's name, inferred from the `name` option.
  * @template TGetter - The view's props getter, inferred from the `props` option.
  */
-export type AddViewOptions<TName extends string | undefined = string, TGetter = PropsGetter> = TransformerOptions<PayloadValueOf<TGetter>> & {
+export type AddViewOptions<TName extends string | undefined = string, TGetter = AddViewPropsGetter<Route, Component>> = TransformerOptions<PayloadValueOf<TGetter>> & {
     /**
      * The name of the view, rendered by `<router-view name="..." />`. Defaults to the unnamed view.
      */

package/dist/types/callbackContext.d.ts

@@ -1,4 +1,3 @@
-import { RedirectStatus } from './router';
 import { RouterPush } from './routerPush';
 export type CallbackContextSuccess = {
     status: 'SUCCESS';
@@ -10,10 +9,6 @@ export type CallbackContextPush = {
 export type CallbackContextRedirect = {
     status: 'REDIRECT';
     to: Parameters<RouterPush>;
-    /**
-     * The status the redirect declared, or undefined to use the router's `redirectStatus`.
-     */
-    redirectStatus: RedirectStatus | undefined;
 };
 export type CallbackContextReject = {
     status: 'REJECT';

package/dist/types/createRouteOptions.d.ts

@@ -1,20 +1,15 @@
-import { Component } from 'vue';
+import { NavigationBehavior } from './navigation';
 import { Param } from './paramTypes';
 import { PrefetchConfig } from './prefetch';
+import { ViewTransitionConfig } from './viewTransition';
 import { RouteMeta } from './register';
-import { Route } from './route';
-import { ResolvedRoute, WithData } from './resolved';
-import { ComponentProps } from '../services/component';
-import { PropsCallbackContext } from './props';
-import { AnyFunction, Identity, MaybePromise } from './utilities';
+import { Route, RouteInternal } from './route';
 import { ToMeta } from './meta';
 import { ToName } from './name';
 import { UrlPart, UrlQueryPart } from '../services/withParams';
 import { RouteContext } from './routeContext';
-import { RouterViewProps } from '../components/routerView';
 import { ToUrl } from './url';
 import { CombineUrl } from '../services/combineUrl';
-import { RouteView } from './routeViews';
 export type WithHost<THost extends string | UrlPart = string | UrlPart> = {
     /**
      * Host part of URL.
@@ -31,20 +26,6 @@ export declare function isWithParent<T extends Record<string, unknown>>(options:
 export type WithoutParent = {
     parent?: never;
 };
-/**
- * This type is used to strip the component and components properties from the options object
- * when creating a Route to simplify and minimize the output type.
- */
-type WithoutComponents = {
-    component: never;
-    components: never;
-};
-export declare function isWithComponent<T extends Record<string, unknown>>(options: T): options is T & {
-    component: Component;
-};
-export declare function isWithComponents<T extends Record<string, unknown>>(options: T): options is T & {
-    components: Record<string, Component>;
-};
 export type CreateRouteOptions<TName extends string | undefined = string | undefined, TMeta extends RouteMeta = RouteMeta> = {
     /**
      * Name for route, used to create route keys and in navigation.
@@ -70,6 +51,12 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
      */
     prefetch?: PrefetchConfig;
+    /** Overrides the parent route and router navigation behavior. */
+    navigation?: NavigationBehavior;
+    /**
+     * Animates navigations to this route with the View Transitions API. Overrides router level viewTransition.
+     */
+    viewTransition?: ViewTransitionConfig;
     /**
      * Type params for additional data intended to be stored in history state, all keys will be optional unless a default is provided.
      */
@@ -78,19 +65,6 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      * An optional parent route to nest this route under.
      */
     parent?: Route;
-    /**
-     * An optional component to render when this route is matched.
-     *
-     * @default RouterView
-     * @deprecated Use the chainable `addView` method on the route instead: `createRoute({ ... }).addView(component, { props })`.
-     */
-    component?: Component;
-    /**
-     * An object of named components to render using named views
-     *
-     * @deprecated Use the chainable `addView` method on the route instead: `createRoute({ ... }).addView(component, { name, props })`.
-     */
-    components?: Record<string, Component>;
     /**
      * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
      */
@@ -100,16 +74,7 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      */
     hoist?: boolean;
 };
-export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions>> & WithData<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<ComponentProps<TComponent>>;
-export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions>> & WithData<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
-export 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]>;
-} & {
-    [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends false ? K : never]: PropsGetter<TOptions, TComponents[K]>;
-};
-export type CreateRouteProps<TOptions extends CreateRouteOptions = CreateRouteOptions> = TOptions['component'] extends Component ? PropsGetter<TOptions, TOptions['component']> : TOptions['components'] extends Record<string, Component> ? RoutePropsRecord<TOptions, TOptions['components']> : RouterViewPropsGetter<TOptions>;
-type ToMatch<TOptions extends CreateRouteOptions, TProps = undefined> = Omit<TOptions, 'meta' | 'name' | 'component' | 'components' | 'parent'> & {
+type ToMatch<TOptions extends CreateRouteOptions> = Omit<TOptions, 'meta' | 'name' | 'parent'> & {
     id: string;
     name: ToName<TOptions['name']>;
     /**
@@ -117,9 +82,9 @@ type ToMatch<TOptions extends CreateRouteOptions, TProps = undefined> = Omit<TOp
      */
     meta: ToMeta<TOptions['meta']>;
     /**
-     * The views this route renders, keyed by view name.
+     * The views this route renders, keyed by view name. Added by `addView`.
      */
-    views: PropsToViews<TProps>;
+    views: {};
     /**
      * The loaders this route runs, keyed by loader name. Always empty here — loaders are only added via
      * the route's `addLoader`.
@@ -130,28 +95,23 @@ type ToMatch<TOptions extends CreateRouteOptions, TProps = undefined> = Omit<TOp
  * The matches for a route, from greatest ancestor to the route itself. Each carries its own views, so
  * there is no second tuple to keep aligned with this one.
  */
-type ToMatches<TOptions extends CreateRouteOptions, TProps = undefined> = TOptions extends {
+type ToMatches<TOptions extends CreateRouteOptions> = TOptions extends {
     parent: infer TParent extends Route;
-} ? [...TParent['matches'], ToMatch<TOptions, TProps>] : [ToMatch<TOptions, TProps>];
-/**
- * Builds a views record from the props argument, which is either a single getter for the unnamed view or
- * a record of getters keyed by view name.
- */
-type PropsToViews<TProps> = [TProps] extends [AnyFunction] ? {
-    default: RouteView<ReturnType<TProps>>;
-} : [TProps] extends [Record<string, AnyFunction>] ? {
-    [K in keyof TProps]: RouteView<ReturnType<TProps[K]>>;
-} : {};
+} ? [...TParent['matches'], ToMatch<TOptions>] : [ToMatch<TOptions>];
 /**
  * The url a route resolves to, combined with its parent's unless the route is hoisted.
  */
 export type ToRouteUrl<TOptions extends CreateRouteOptions> = TOptions extends {
     parent: infer TParent extends Route;
-} ? TOptions['hoist'] extends true ? ToUrl<TOptions & WithoutComponents> : CombineUrl<TParent, ToUrl<TOptions & WithoutComponents>> : ToUrl<Identity<TOptions & WithoutComponents>>;
+} ? TOptions['hoist'] extends true ? ToUrl<TOptions> : CombineUrl<TParent, ToUrl<TOptions>> : ToUrl<TOptions>;
+/**
+ * The matches for a route, before any views or loaders are added.
+ */
+export type ToRouteMatches<TOptions extends CreateRouteOptions> = ToMatches<TOptions>;
+export type ToRoute<TOptions extends CreateRouteOptions> = CreateRouteOptions extends TOptions ? Route : Route<ToRouteUrl<TOptions>, ToRouteMatches<TOptions>>;
 /**
- * The matches for a route, with the props argument resolved to the views of its own match.
+ * Nests a route under its parent. A hoisted route keeps everything of its parent's except the url: its own
+ * url stands alone and it inherits none of the parent's aliases.
  */
-export type ToRouteMatches<TOptions extends CreateRouteOptions, TProps> = ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>;
-export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined = undefined> = CreateRouteOptions extends TOptions ? Route : Route<ToRouteUrl<TOptions>, ToRouteMatches<TOptions, TProps>>;
-export declare function combineRoutes(parent: Route, child: Route): Route;
+export declare function combineRoutes(parent: Route, child: Route, hoisted?: boolean): Route & RouteInternal;
 export {};

package/dist/types/hooks.d.ts

@@ -10,6 +10,7 @@ import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './ro
 import { RouterAbort } from './routerAbort';
 import { CallbackContextAbort, CallbackContextPush, CallbackContextRedirect, CallbackContextReject, CallbackContextSuccess } from './callbackContext';
 import { RouteUpdate } from './routeUpdate';
+import { NavigationProgressTracker } from '../services/createNavigationProgress';
 export declare function getHooks(value: Record<string, unknown> | undefined | null): Hooks[];
 export declare function combineHooks(parent: Route, child: Route): Hooks[];
 export type InternalRouteHooks<TRoute extends Route = Route, TContext extends RouteContext[] | undefined = undefined> = {
@@ -89,6 +90,7 @@ type AfterHookContext<TRoute extends Route, TRoutes extends Routes, TRejections
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
     update: RouteUpdate<ResolvedRouteUnion<TRoute>>;
+    signal: AbortSignal;
 };
 type BeforeHookContext<TRouteTo extends Route, TRoutes extends Routes, TRejections extends Rejections> = {
     reject: RouterReject<TRejections>;
@@ -96,6 +98,7 @@ type BeforeHookContext<TRouteTo extends Route, TRoutes extends Routes, TRejectio
     replace: RouterReplace<TRoutes>;
     update: RouteUpdate<ResolvedRouteUnion<TRouteTo>>;
     abort: RouterAbort;
+    signal: AbortSignal;
 };
 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;
@@ -129,14 +132,15 @@ export type AfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends
 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 | CallbackContextRedirect | CallbackContextReject | CallbackContextAbort;
 export type AfterHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject;
-export type BeforeHookRunner = <TRoutes extends Routes>(context: {
+export type HookRunnerContext<TRoutes extends Routes = Routes> = {
     to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
+    signal: AbortSignal;
+};
+export type BeforeHookRunner = <TRoutes extends Routes>(context: HookRunnerContext<TRoutes> & {
+    progress?: NavigationProgressTracker;
 }) => Promise<BeforeHookResponse>;
-export type AfterHookRunner = <TRoutes extends Routes>(context: {
-    to: RouterResolvedRouteUnion<TRoutes> | null;
-    from: RouterResolvedRouteUnion<TRoutes> | null;
-}) => Promise<AfterHookResponse>;
+export type AfterHookRunner = <TRoutes extends Routes>(context: HookRunnerContext<TRoutes>) => Promise<AfterHookResponse>;
 export type RejectionHookContext<TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = {
     to: ResolvedRouteUnion<TRouteTo> | null;
     from: ResolvedRouteUnion<TRouteFrom> | null;

package/dist/types/navigation.d.ts

@@ -0,0 +1,38 @@
+import { ComputedRef } from 'vue';
+import { ResolvedRoute } from './resolved';
+/** Whether navigation commits immediately or waits for its props, loaders, and components. */
+export type NavigationBehavior = 'progressive' | 'blocking';
+/**
+ * The navigation under way, if any, and how far it has come. A navigation is under way from the moment it
+ * is asked for until the route it leads to has everything it renders with, or it is rejected, aborted, or
+ * superseded. Its progress is counted in the units of work it waits on: its before hooks, its props getters
+ * and loaders, and the async components it renders. Every unit counts the same.
+ */
+export type UseNavigation = {
+    /**
+     * True while a navigation is under way.
+     */
+    pending: ComputedRef<boolean>;
+    /**
+     * The route the navigation under way leads to. Null when idle, or when the url matches no route.
+     */
+    to: ComputedRef<ResolvedRoute | null>;
+    /**
+     * The route the navigation under way leaves. Null when idle, or for the first navigation.
+     */
+    from: ComputedRef<ResolvedRoute | null>;
+    /**
+     * How many units have settled so far. Equal to `total` once a navigation reaches its route, and zero
+     * once one ends by being rejected or aborted.
+     */
+    settled: ComputedRef<number>;
+    /**
+     * How many units the navigation waits on in all. Known up front except for before hooks, which are
+     * added as they start.
+     */
+    total: ComputedRef<number>;
+    /**
+     * The share of units settled, between 0 and 1. Zero while idle.
+     */
+    progress: ComputedRef<number>;
+};

package/dist/types/prefetch.d.ts

@@ -11,10 +11,15 @@ export type PrefetchConfigOptions = {
      */
     components?: boolean | PrefetchStrategy;
     /**
-     * When true any props for routes will be prefetched
+     * When true route props will be prefetched
      * @default false
      */
     props?: boolean | PrefetchStrategy;
+    /**
+     * When true route loaders will be prefetched
+     * @default false
+     */
+    loaders?: boolean | PrefetchStrategy;
 };
 /**
  * Determines what assets are prefetched. A boolean enables or disables all prefetching.

package/dist/types/props.d.ts

@@ -1,24 +1,7 @@
-import { CreateRouteOptions } from './createRouteOptions';
 import { Route } from './route';
-import { RouterReject } from './routerReject';
-import { RouterPush } from './routerPush';
-import { RouterReplace } from './routerReplace';
-import { ExtractRouteContextRejections, ExtractRouteContextRoutes } from './routeContext';
-import { ResolvedRoute } from './resolved';
-import { RouteUpdate } from './routeUpdate';
 import { LoadersDataReturnType } from './routeLoaders';
 import { ViewsPropsReturnType } from './routeViews';
 import { LastInArray } from './utilities';
-/**
- * Context provided to props callback functions
- */
-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']>;
-};
 export type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
     name: string;
     props: unknown;

package/dist/types/redirects.d.ts

@@ -16,6 +16,10 @@ export type RouteRedirects<TRoute extends Route = Route> = {
 };
 type RedirectHookContext<TRoutes extends Routes> = {
     replace: RouterReplace<TRoutes>;
+    /**
+     * The router's status for a redirect that does not declare its own.
+     */
+    redirectStatus: RedirectStatus;
 };
 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: UrlParamsReading<TRouteFrom>) => UrlParamsWriting<TRouteTo>;

package/dist/types/resolved.d.ts

@@ -3,11 +3,25 @@ import { LastInArray } from './utilities';
 import { ExtractRouteStateParamsAsOptional } from './state';
 import { UrlString } from './urlString';
 import { UrlParamsReading } from './url';
-import { GetTitleCallback } from './routeTitle';
+import { GetRouteTitle, GetTitleCallback } from './routeTitle';
+import { Hooks } from '../models/hooks';
 /**
  * The match a route resolved to, which is the last of its matches. Falls back to the wide match type when
  * the matches are not a concrete tuple, so an unregistered router stays assignable.
  */
+export declare const IS_RESOLVED_ROUTE_SYMBOL: unique symbol;
+/**
+ * A type guard for determining if a value is a ResolvedRoute.
+ * @param value - The value to check.
+ * @returns `true` if the value is a ResolvedRoute, otherwise `false`.
+ * @group Type Guards
+ */
+export declare function isResolvedRoute(value: unknown): value is ResolvedRoute & ResolvedRouteInternal;
+export type ResolvedRouteInternal = {
+    [IS_RESOLVED_ROUTE_SYMBOL]: true;
+    hooks: Hooks[];
+    getRouteTitle: GetRouteTitle;
+};
 type MatchedRoute<TMatches> = LastInArray<TMatches, CreatedRouteOptions> extends infer TMatched ? unknown extends TMatched ? CreatedRouteOptions : TMatched : never;
 /**
  * Represents a route that the router has matched to current browser location.
@@ -40,9 +54,15 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      */
     state: ExtractRouteStateParamsAsOptional<TRoute['state']>;
     /**
-     * String value of the resolved URL.
+     * String value of the resolved URL. When the route was matched through an alias this is the alias url,
+     * so navigating to it again stays where the user is.
      */
     href: UrlString;
+    /**
+     * String value of the route's own URL, built from its path and the resolved params. The same as `href`
+     * unless the route was matched through an alias.
+     */
+    canonical: UrlString;
     /**
      * Query value of the route.
      */

package/dist/types/route.d.ts

@@ -12,6 +12,7 @@ import { Hooks } from '../models/hooks';
 import { RouteRedirect } from './redirects';
 import { RouteViews } from './routeViews';
 import { LoadersDataReturnType, RouteLoaders } from './routeLoaders';
+import { RouteAlias } from './routeAlias';
 export declare const IS_ROUTE_SYMBOL: unique symbol;
 export declare function isRoute(value: unknown): value is Route & RouteInternal;
 export type RouteInternal = {
@@ -20,6 +21,7 @@ export type RouteInternal = {
     hooks: Hooks[];
     redirect: RouteRedirect;
     getTitle: GetRouteTitle;
+    aliases: RouteAlias[];
 };
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
@@ -27,10 +29,9 @@ export type RouteInternal = {
 export type Routes = readonly Route[];
 /**
  * The Route properties originally provided to `createRoute`, plus the views that route renders and the
- * loaders it runs. The deprecated `component`/`components` options are folded into `views` (see
- * {@link RouteViews}).
+ * loaders it runs.
  */
-export type CreatedRouteOptions = Omit<CreateRouteOptions, 'component' | 'components'> & {
+export type CreatedRouteOptions = CreateRouteOptions & {
     id: string;
     views: RouteViews;
     loaders: RouteLoaders;

package/dist/types/routeAlias.d.ts

@@ -0,0 +1,41 @@
+import { Url } from './url';
+/**
+ * What an alias transform is given: the url that matched and the params the alias pattern parsed from it.
+ *
+ * @template TParams - The alias's own params, typed by the alias pattern.
+ */
+export type AliasTransformContext<TParams = Record<string, unknown>> = {
+    /**
+     * The url that matched the alias.
+     */
+    url: string;
+    /**
+     * The params the alias pattern parsed from the url, typed by the alias's own params rather than the
+     * route's.
+     */
+    params: TParams;
+};
+/**
+ * Maps what an alias matched into the params the route declares. Runs synchronously during matching. Any
+ * param the route declares that the alias pattern does not carry must be supplied here.
+ *
+ * @template TParams - The alias's own params.
+ * @template TRouteParams - The params of the route the alias belongs to.
+ */
+export type AliasTransform<TParams = Record<string, unknown>, TRouteParams = Record<string, unknown>> = (context: AliasTransformContext<TParams>) => TRouteParams;
+/**
+ * An alias combined with every ancestor into a single url the router can match, plus the transform that
+ * maps everything that url parsed into the route's params. The transform is the composition of each
+ * level's own transform, so it stays local to the segment each level aliased.
+ */
+export type RouteAlias = {
+    url: Url;
+    transform: (url: string, params: Record<string, unknown>) => Record<string, unknown>;
+};
+/**
+ * An alias a url matched and the params that alias parsed from it.
+ */
+export type RouteAliasMatch = {
+    url: RouteAlias['url'];
+    params: Record<string, unknown>;
+};

package/dist/types/routeCallbackContext.d.ts

@@ -16,6 +16,7 @@ export type RouteCallbackContext<TRoute extends Route> = {
     push: RouterPush<[TRoute] | RouteContextToRoute<TRoute['context']>>;
     replace: RouterReplace<[TRoute] | RouteContextToRoute<TRoute['context']>>;
     update: RouteUpdate<ResolvedRoute<TRoute>>;
+    signal: AbortSignal;
     parent: RouteCallbackParent<TRoute>;
 };
 /**

package/dist/types/routeViews.d.ts

@@ -3,26 +3,24 @@ import { Component } from 'vue';
 import { PrefetchConfig } from './prefetch';
 import { AnyFunction } from './utilities';
 /**
- * A single view: what to render, how to get its props, and how to prefetch it. `component` is optional
- * because a route can bind props to the nested RouterView it renders without declaring a component.
+ * A single view: what to render, how to get its props, and how to prefetch it.
  *
  * @template TProps - What this view's props getter returns, carried so parent props can be typed from it.
  */
 export type RouteView<TProps = undefined> = {
-    component?: Component;
+    component: Component;
     props?: AnyFunction<TProps>;
     prefetch?: PrefetchConfig;
     transformer?: AnyPayloadTransformer;
 };
 /**
- * The views for a single route, keyed by view name (the unnamed view under 'default'). Indexed by depth in
- * `route.views` — parallel to how `route.matches` indexes the matched options, which is where a route's id
- * comes from at a given depth.
+ * The views for a single match, keyed by view name (the unnamed view under 'default'). Each match in
+ * `route.matches` carries its own views.
  */
 export type RouteViews = Record<string, RouteView<unknown>>;
 /**
  * The props a child sees for a parent's views. A lone unnamed view is given directly rather than under a
- * 'default' key, matching how the props argument is written. Each view's props are always a promise,
+ * 'default' key. Each view's props are always a promise,
  * since the parent's props may not have been computed when the child's getter runs.
  */
 export type ViewsPropsReturnType<TViews> = keyof ViewsWithProps<TViews> extends never ? undefined : keyof ViewsWithProps<TViews> extends 'default' ? ParentViewProps<Extract<ViewsWithProps<TViews>, {

package/dist/types/routeWithMethods.d.ts

@@ -1,3 +1,4 @@
+import { RouteAddAlias } from './addAlias';
 import { RouteAddLoader } from './addLoader';
 import { RouteAddView } from './addView';
 import { InternalRouteHooks } from './hooks';
@@ -6,11 +7,11 @@ import { CreatedRouteOptions, Route } from './route';
 import { RouteSetTitle } from './routeTitle';
 import { Url } from './url';
 /**
- * A route plus every chainable/available method: addView, addLoader, hooks, redirects, and title. The type
+ * A route plus every chainable/available method: addView, addLoader, addAlias, hooks, redirects, and title. The type
  * level counterpart to `withRouteMethods`.
  *
  * Takes the url and matches rather than an assembled route so that adding a view or a loader can rebuild
  * from them directly. Taking the route would mean re-deriving the url from it on every call, and that
  * reference is what made chained calls nest one inside the last.
  */
-export type RouteWithMethods<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = Route<TUrl, TMatches> & RouteAddView<TUrl, TMatches> & RouteAddLoader<TUrl, TMatches> & InternalRouteHooks<Route<TUrl, TMatches>, Route<TUrl, TMatches>['context']> & RouteRedirects<Route<TUrl, TMatches>> & RouteSetTitle<Route<TUrl, TMatches>>;
+export type RouteWithMethods<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = Route<TUrl, TMatches> & RouteAddView<TUrl, TMatches> & RouteAddLoader<TUrl, TMatches> & RouteAddAlias<TUrl, TMatches> & InternalRouteHooks<Route<TUrl, TMatches>, Route<TUrl, TMatches>['context']> & RouteRedirects<Route<TUrl, TMatches>> & RouteSetTitle<Route<TUrl, TMatches>>;

package/dist/types/router.d.ts

@@ -1,3 +1,4 @@
+import { NavigationBehavior } from './navigation';
 import { App, InjectionKey, Ref } from 'vue';
 import { RouterHistoryMode } from '../services/createRouterHistory';
 import { TransformerOptions } from '../services/payload';
@@ -14,6 +15,7 @@ import { RouterPlugin } from './routerPlugin';
 import { RoutesName } from './routesMap';
 import { ExtractRejections, ExtractRejectionTypes, Rejections, BuiltInRejectionType } from './rejection';
 import { PayloadValueError } from '../errors/payloadValueError';
+import { ViewTransitionConfig } from './viewTransition';
 /**
  * Options to initialize a {@link Router} instance.
  */
@@ -44,6 +46,17 @@ export type RouterOptions = TransformerOptions & {
      * Determines what assets are prefetched when router-link is rendered for a specific route
      */
     prefetch?: PrefetchConfig;
+    /**
+     * Whether navigation waits for props, loaders, and components before committing.
+     * @default 'progressive'
+     */
+    navigation?: NavigationBehavior;
+    /**
+     * Animates navigations with the View Transitions API. Overridden per route and per navigation.
+     *
+     * @default false
+     */
+    viewTransition?: ViewTransitionConfig;
     /**
      * Components assigned to each type of rejection your router supports.
      */

package/dist/types/routerLink.d.ts

@@ -3,7 +3,7 @@ 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 | UrlString | undefined;
+export type ToCallback<TRouter extends Router> = (resolve: TRouter['resolve']) => ResolvedRoute | UrlString;
 export type RouterLinkProps<TRouter extends Router> = RouterPushOptions & {
     /**
      * The url string to navigate to or a callback that returns a url string