@kitbag/router 0.26.0 → 0.27.0

package/dist/main.d.ts

@@ -3,6 +3,8 @@ import { RegisteredRouter } from './types/register';
 export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, PropsGetter, RouterViewPropsGetter, CreateRouteProps, ToRoute } from './types/createRouteOptions';
 export type { RouteAddView, AddViewOptions, AddViewPropsGetter, AddViewPropsCallbackContext } from './types/addView';
 export type { RouteAddLoader, AddLoaderOptions, LoaderGetter } from './types/addLoader';
+export type { RouteAddAlias, AddAliasOptions } from './types/addAlias';
+export type { AliasTransform, AliasTransformContext } from './types/routeAlias';
 export type { RouteCallbackContext } from './types/routeCallbackContext';
 export type { RouteViews } from './types/routeViews';
 export type { RouteLoader, RouteLoaders } from './types/routeLoaders';
@@ -14,10 +16,12 @@ export * from './types/querySource';
 export type { RouteRedirects } from './types/redirects';
 export * from './types/register';
 export type { Rejection, RejectionType, Rejections } from './types/rejection';
-export * from './types/resolved';
+export { isResolvedRoute } from './types/resolved';
+export type { ResolvedRoute, WithData, ResolvedRouteUnion, RouterResolvedRouteUnion } from './types/resolved';
 export type { Route, CreatedRouteOptions } from './types/route';
 export * from './types/router';
 export * from './types/routerLink';
+export type { RouterProgressProps } from './components/routerProgress';
 export type { RouterPlugin, CreateRouterPluginOptions } from './types/routerPlugin';
 export * from './types/routerPush';
 export * from './types/routerPush';
@@ -30,6 +34,7 @@ export * from './types/routerRoute';
 export * from './types/urlString';
 export type { Url, CreateUrlOptions, ParseUrlOptions } from './types/url';
 export * from './types/useLink';
+export * from './types/navigation';
 export { DuplicateParamsError } from './errors/duplicateParamsError';
 export { LoaderDataAccessError } from './errors/loaderDataAccessError';
 export { LoaderNameConflict } from './errors/loaderNameConflict';
@@ -39,6 +44,7 @@ export { PayloadValueError } from './errors/payloadValueError';
 export { RouterNotInstalledError } from './errors/routerNotInstalledError';
 export { UseRouteInvalidError } from './errors/useRouteInvalidError';
 export { SsrOptionRequiredError } from './errors/ssrOptionRequiredError';
+export { UnreachableRouteError } from './errors/unreachableRouteError';
 export { createRoute } from './services/createRoute';
 export { createRejection } from './services/createRejection';
 export { createExternalRoute } from './services/createExternalRoute';
@@ -113,6 +119,15 @@ export declare const RouterView: RouterAssets<RegisteredRouter>['RouterView'];
  * @group Components
  */
 export declare const RouterLink: RouterAssets<RegisteredRouter>['RouterLink'];
+/**
+ * A component to render a bar across the top of the page while a navigation is pending, filled by how
+ * much of the navigation's work has settled.
+ *
+ * @param props - The props to pass to the router progress component.
+ * @returns The router progress component.
+ * @group Components
+ */
+export declare const RouterProgress: RouterAssets<RegisteredRouter>['RouterProgress'];
 /**
  * A composition to access the current route or verify a specific route name within a Vue component.
  * This function provides two overloads:
@@ -164,9 +179,18 @@ export declare const useLink: RouterAssets<RegisteredRouter>['useLink'];
  * @group Compositions
  */
 export declare const useRejection: RouterAssets<RegisteredRouter>['useRejection'];
+/**
+ * A composition to access the navigation under way: whether one is pending, which routes it leaves and
+ * leads to, and how much of the work it waits on has settled.
+ *
+ * @returns {UseNavigation} Reactive state of the navigation under way.
+ * @group Compositions
+ */
+export declare const useNavigation: RouterAssets<RegisteredRouter>['useNavigation'];
 declare module 'vue' {
     interface GlobalComponents {
         RouterView: typeof RouterView;
         RouterLink: typeof RouterLink;
+        RouterProgress: typeof RouterProgress;
     }
 }

package/dist/main.spec-d.d.ts

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

package/dist/services/addAlias.d.ts

@@ -0,0 +1,19 @@
+import { AddAliasOptions } from '../types/addAlias';
+import { AliasTransform, RouteAlias } from '../types/routeAlias';
+import { CreatedRouteOptions, Route } from '../types/route';
+/**
+ * The loose runtime signature of the `addAlias` method. Purposely wide: it returns Route rather than the
+ * refined chainable route `RouteAddAlias` describes.
+ */
+export type AddAlias = (options: AddAliasOptions, transform?: AliasTransform) => Route;
+/**
+ * The aliases a nested route inherits: each of its parent's aliases combined with the route's own segment.
+ * The parent's own url is left out, since combined with the route's own segment it is the route's own url,
+ * not an alias.
+ */
+export declare function combineAliases(parent: Route, child: Route): RouteAlias[];
+/**
+ * The aliases an `addAlias` call adds: the alias segment combined with every url the parent can be reached
+ * under, or standing alone when there is no parent to combine with.
+ */
+export declare function createAliases(match: CreatedRouteOptions, options: AddAliasOptions, transform: AliasTransform | undefined): RouteAlias[];

package/dist/services/addAlias.spec-d.d.ts

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

package/dist/services/addAlias.spec.d.ts

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

package/dist/services/createCanonicalUrl.d.ts

@@ -0,0 +1,14 @@
+import { RouteAliasMatch } from '../types/routeAlias';
+import { Url } from '../types/url';
+import { UrlString } from '../types/urlString';
+type CreateCanonicalUrlContext = {
+    route: Url;
+    params: Record<string, unknown>;
+    alias?: RouteAliasMatch;
+};
+/**
+ * Adds undeclared query values and a hash to the route's own url. Declared query keys (including
+ * omitted optional params) and a declared hash belong to the route and cannot be replaced by extras.
+ */
+export declare function createCanonicalUrl(visitedUrl: UrlString, context: CreateCanonicalUrlContext): UrlString;
+export {};

package/dist/services/createCanonicalUrl.spec.d.ts

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

package/dist/services/createDataStore.d.ts

@@ -39,6 +39,10 @@ export type DataStore = {
      * What is known about a key, without waiting for it. Reactive, and readable during render.
      */
     get: (key: string) => DataResult;
+    /**
+     * Aborts when the store is disposed, so a getter still running can stop work nothing will read.
+     */
+    signal: AbortSignal;
     /**
      * Ends the store. Every value is rejected so that anything waiting on one resumes rather than staying
      * suspended, then discarded.

package/dist/services/createNavigationProgress.d.ts

@@ -0,0 +1,49 @@
+import { ResolvedRoute } from '../types/resolved';
+import { UseNavigation } from '../types/navigation';
+/**
+ * The units of work one navigation waits on, counted as they are planned and as they settle. Every method
+ * is a no-op once the navigation is over or another has begun, so a unit settling late never counts
+ * against a later navigation.
+ */
+export type NavigationProgressTracker = {
+    /**
+     * Plans units that will be tracked later.
+     */
+    expect: (count: number) => void;
+    /**
+     * Counts each unit as settled when it does, however it settles. Only units already expected.
+     */
+    track: (...units: Promise<unknown>[]) => void;
+    /**
+     * Nothing more will be tracked. The navigation ends once every tracked unit has settled.
+     */
+    close: () => void;
+    /**
+     * Ends the navigation as having gone nowhere, wiping its counts.
+     */
+    abort: () => void;
+};
+type BeginContext = {
+    to: ResolvedRoute | null;
+    from: ResolvedRoute | null;
+    /**
+     * Units known before anything runs, so the total never shrinks a navigation's progress midway.
+     */
+    expected: number;
+    /**
+     * An inert tracker counts nothing and leaves the state alone, for navigations with nothing to show.
+     */
+    inert?: boolean;
+};
+export type NavigationProgress = UseNavigation & {
+    /**
+     * Begins counting a navigation, discarding whatever the navigation before it still had outstanding.
+     */
+    begin: (context: BeginContext) => NavigationProgressTracker;
+    /**
+     * Aborts the navigation being counted, if any.
+     */
+    stop: () => void;
+};
+export declare function createNavigationProgress(): NavigationProgress;
+export {};

package/dist/services/createNavigationProgress.spec.d.ts

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

package/dist/services/createNavigationSignals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Which navigation is under way. Only the latest navigation counts: beginning another makes the one before
+ * it moot, and so does stopping the router.
+ */
+export type NavigationSignals = {
+    /**
+     * Begins a navigation, aborting the one under way. The controller aborts once a later navigation begins
+     * or the router stops, and is already aborted for a navigation begun after the router stopped. The
+     * navigation aborts it itself when it ends without committing.
+     */
+    begin: () => AbortController;
+    /**
+     * Aborts the navigation under way, and every one begun afterwards.
+     */
+    stop: () => void;
+};
+export declare function createNavigationSignals(): NavigationSignals;

package/dist/services/createNavigationSignals.spec.d.ts

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

package/dist/services/createResolvedRoute.d.ts

@@ -1,4 +1,13 @@
 import { RouterResolveOptions } from '../types/routerResolve';
 import { ResolvedRoute } from '../types/resolved';
 import { Route } from '../types/route';
-export declare function createResolvedRoute(route: Route, params?: Record<string, unknown>, options?: RouterResolveOptions): ResolvedRoute;
+import { RouteAliasMatch } from '../types/routeAlias';
+type CreateResolvedRouteOptions = RouterResolveOptions & {
+    /**
+     * The alias the route was matched through, which is what `href` is built from instead of the route's
+     * own url.
+     */
+    alias?: RouteAliasMatch;
+};
+export declare function createResolvedRoute(route: Route, params?: Record<string, unknown>, options?: CreateResolvedRouteOptions): ResolvedRoute;
+export {};

package/dist/services/createRouteValueStore.d.ts

@@ -20,6 +20,10 @@ export type RouteValueResponse = CallbackContextSuccess | CallbackContextPush |
 export type RouteValueResponses = {
     props: Promise<RouteValueResponse>;
     loaders: Promise<RouteValueResponse>;
+    /**
+     * Each value on its own as it settles, for whoever counts them.
+     */
+    values: Promise<unknown>[];
 };
 /**
  * A store of a route's values, whichever store that is.

package/dist/services/createRouterAssets.d.ts

@@ -2,6 +2,7 @@ import { Router, RouterRoutes, RouterRejections } from '../types/router';
 import { InjectionKey } from 'vue';
 import { createRouterView } from '../components/routerView';
 import { createRouterLink } from '../components/routerLink';
+import { createRouterProgress } from '../components/routerProgress';
 import { createUseRoute } from '../compositions/useRoute';
 import { createUseRouter } from '../compositions/useRouter';
 import { createUseQueryValue } from '../compositions/useQueryValue';
@@ -9,6 +10,7 @@ import { createUseLink } from '../compositions/useLink';
 import { createIsRoute } from '../guards/routes';
 import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../types/hooks';
 import { createUseRejection } from '../compositions/useRejection';
+import { createUseNavigation } from '../compositions/useNavigation';
 export type RouterAssets<TRouter extends Router> = {
     /**
      * Registers a hook that is called before a route is left. Must be called from setup.
@@ -70,6 +72,15 @@ export type RouterAssets<TRouter extends Router> = {
      * @group Components
      */
     RouterLink: ReturnType<typeof createRouterLink<TRouter>>;
+    /**
+     * A component to render a bar across the top of the page while a navigation is pending, filled by how
+     * much of the navigation's work has settled.
+     *
+     * @param props - The props to pass to the router progress component.
+     * @returns The router progress component.
+     * @group Components
+     */
+    RouterProgress: ReturnType<typeof createRouterProgress<TRouter>>;
     /**
      * A composition to access the current route or verify a specific route name within a Vue component.
      * This function provides two overloads:
@@ -121,6 +132,14 @@ export type RouterAssets<TRouter extends Router> = {
      * @group Compositions
      */
     useRejection: ReturnType<typeof createUseRejection<TRouter>>;
+    /**
+     * A composition to access the navigation under way: whether one is pending, which routes it leaves and
+     * leads to, and how much of the work it waits on has settled.
+     *
+     * @returns {UseNavigation} Reactive state of the navigation under way.
+     * @group Compositions
+     */
+    useNavigation: ReturnType<typeof createUseNavigation<TRouter>>;
 };
 export declare function createRouterAssets<TRouter extends Router>(router: TRouter): RouterAssets<TRouter>;
 export declare function createRouterAssets<TRouter extends Router>(routerKey: InjectionKey<TRouter>): RouterAssets<TRouter>;

package/dist/services/createRouterHooks.d.ts

@@ -1,6 +1,7 @@
 import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook, RejectionHookRunner, AddRejectionHook } from '../types/hooks';
 import { HasVueAppStore } from './createVueAppStore';
-export declare const getRouterHooksKey: (routerKey: import('vue').InjectionKey<import('../main').Router>) => import('vue').InjectionKey<RouterHooks>;
+import { RedirectStatus } from '../types/router';
+export declare const getRouterHooksKey: (routerKey: import('vue').InjectionKey<import('../types/router').Router>) => import('vue').InjectionKey<RouterHooks>;
 export type RouterHooks = HasVueAppStore & {
     runBeforeRouteHooks: BeforeHookRunner;
     runAfterRouteHooks: AfterHookRunner;
@@ -17,4 +18,8 @@ export type RouterHooks = HasVueAppStore & {
     onError: AddErrorHook;
     onRejection: AddRejectionHook;
 };
-export declare function createRouterHooks(): RouterHooks;
+type RouterHooksOptions = {
+    redirectStatus: RedirectStatus;
+};
+export declare function createRouterHooks({ redirectStatus }: RouterHooksOptions): RouterHooks;
+export {};

package/dist/services/createUniqueIdSequence.d.ts

@@ -1,2 +1 @@
 export declare function createUniqueIdSequence(): () => string;
-export declare function isFirstUniqueSequenceId(id: string): boolean;

package/dist/services/getInitialUrl.d.ts

@@ -1 +1,2 @@
-export declare function getInitialUrl(initialUrl?: string): string;
+import { RouterHistoryMode } from './createRouterHistory';
+export declare function getInitialUrl(initialUrl?: string, mode?: RouterHistoryMode): string;

package/dist/services/getMatchesForUrl.d.ts

@@ -4,5 +4,9 @@ import { ParseUrlOptions } from '../types/url';
 type MatchOptions = {
     state?: Partial<unknown>;
 } & ParseUrlOptions;
+/**
+ * Every route's own url is tried before any alias, so an alias never outranks another route's own url
+ * regardless of the order the routes were defined in.
+ */
 export declare function getMatchForUrl(routes: Routes, url: string, options?: MatchOptions): ResolvedRoute | undefined;
 export {};

package/dist/services/getRoutesForRouter.d.ts

@@ -4,12 +4,13 @@ import { BuiltInRejectionType, Rejection, RejectionInternal } from '../types/rej
 import { RouterOptions } from '../types/router';
 /**
  * Takes in routes and plugins and returns a list of routes with the base route inserted if provided.
- * Also checks for duplicate names in the routes.
+ * Also checks for duplicate names and unreachable paths in the routes.
  *
  * @throws {DuplicateNamesError} If there are duplicate names in the routes.
+ * @throws {UnreachableRouteError} If a named route's path does not start with `/`.
  */
 export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?: RouterPlugin[], options?: RouterOptions): {
-    routes: (import('../main').Url & {
+    routes: (import('../types/url').Url & {
         id: string;
         matches: import('../types/route').CreatedRouteOptions[];
         name: string;

package/dist/services/routeRegex.d.ts

@@ -7,13 +7,18 @@ export declare const regexCatchAll = "[^/]*";
 export declare const regexGreedyCatchAll = ".*";
 export declare const regexCaptureAll = "([^/]*)";
 export declare const regexGreedyCaptureAll = "(.*)";
+export declare function escapeRegExp(string: string): string;
 export declare function splitByMatches(string: string, regexp: RegExp): string[];
 export declare function generateRouteHostRegexPattern(host: string): RegExp;
 export declare function generateRoutePathRegexPattern(path: string): RegExp;
 export declare function generateRouteHashRegexPattern(hash: string): RegExp;
 export declare function generateRouteQueryRegexPatterns(query: string): RegExp[];
 export declare function replaceParamSyntaxWithCatchAlls(value: string): string;
-export declare function replaceIndividualParamWithCaptureGroup(path: UrlPart, paramName: string): string;
+/**
+ * A pattern that captures one param and matches the rest of the part literally, with every other param
+ * replaced by a catch-all.
+ */
+export declare function replaceParamWithCaptureGroupAndEscapeRest(part: UrlPart, paramName: string): string;
 export declare function isOptionalParamSyntax(value: string): boolean;
 export declare function isRequiredParamSyntax(value: string): boolean;
 export declare function isGreedyParamSyntax(value: string): boolean;

package/dist/services/updateResolvedRoute.d.ts

@@ -0,0 +1,7 @@
+import { ResolvedRoute } from '../types/resolved';
+import { RouterResolveOptions } from '../types/routerResolve';
+/**
+ * Applies query, hash, and state to an already resolved route the same way a push with those options
+ * changes the url. Query values are appended, hash and state values override.
+ */
+export declare function updateResolvedRoute(route: ResolvedRoute, options: RouterResolveOptions): ResolvedRoute;

package/dist/services/updateResolvedRoute.spec.d.ts

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

package/dist/services/withRouteMethods.d.ts

@@ -1,7 +1,7 @@
 import { Route } from '../types/route';
 /**
- * Attaches the chainable, immutable route methods — `addView` and `addLoader`. Each call rebuilds the
- * route's own (last) match and returns a new route with the methods re-attached, so neither mutates the
- * route it was called on, and chaining one never drops the other.
+ * Attaches the chainable, immutable route methods — `addView`, `addLoader`, and `addAlias`. Each call
+ * rebuilds the route's own (last) match, or its aliases, and returns a new route with the methods
+ * re-attached, so none mutates the route it was called on, and chaining one never drops another.
  */
 export declare function withRouteMethods<TRoute extends Route>(route: TRoute): TRoute;

package/dist/tests/loaderPrefetch.browser.spec.d.ts

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

package/dist/tests/navigationProgress.spec.d.ts

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

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/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

@@ -2,7 +2,7 @@ import { Component } from 'vue';
 import { Param } from './paramTypes';
 import { PrefetchConfig } from './prefetch';
 import { RouteMeta } from './register';
-import { Route } from './route';
+import { Route, RouteInternal } from './route';
 import { ResolvedRoute, WithData } from './resolved';
 import { ComponentProps } from '../services/component';
 import { PropsCallbackContext } from './props';
@@ -153,5 +153,9 @@ export type ToRouteUrl<TOptions extends CreateRouteOptions> = TOptions extends {
  */
 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;
+/**
+ * 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 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,36 @@
+import { ComputedRef } from 'vue';
+import { ResolvedRoute } from './resolved';
+/**
+ * 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

@@ -17,6 +17,7 @@ export type PropsCallbackContext<TRoute extends Route = Route, TOptions extends
     push: RouterPush<[TRoute] | ExtractRouteContextRoutes<TOptions>>;
     replace: RouterReplace<[TRoute] | ExtractRouteContextRoutes<TOptions>>;
     update: RouteUpdate<ResolvedRoute<TRoute>>;
+    signal: AbortSignal;
     parent: PropsCallbackParent<TOptions['parent']>;
 };
 export type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {

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