@kitbag/router 0.26.1 → 0.28.0

package/dist/main.d.ts

@@ -1,8 +1,10 @@
 import { RouterAssets } from './services/createRouterAssets';
 import { RegisteredRouter } from './types/register';
-export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, PropsGetter, RouterViewPropsGetter, CreateRouteProps, ToRoute } from './types/createRouteOptions';
+export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, 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,8 @@ export * from './types/routerRoute';
 export * from './types/urlString';
 export type { Url, CreateUrlOptions, ParseUrlOptions } from './types/url';
 export * from './types/useLink';
+export * from './types/viewTransition';
+export * from './types/navigation';
 export { DuplicateParamsError } from './errors/duplicateParamsError';
 export { LoaderDataAccessError } from './errors/loaderDataAccessError';
 export { LoaderNameConflict } from './errors/loaderNameConflict';
@@ -39,6 +45,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';
@@ -53,6 +60,7 @@ export { literal } from './services/literal';
 export { createParam } from './services/createParam';
 export { createRouter } from './services/createRouter';
 export { createUrl } from './services/createUrl';
+export type { ViewTransitionProps } from './components/viewTransition';
 /**
  * Registers a hook that is called before a route is left. Must be called from setup.
  * This is useful for performing actions or cleanups before navigating away from a route component.
@@ -113,6 +121,17 @@ export declare const RouterView: RouterAssets<RegisteredRouter>['RouterView'];
  * @group Components
  */
 export declare const RouterLink: RouterAssets<RegisteredRouter>['RouterLink'];
+/** Names a shared element for a view transition. @group Components */
+export declare const ViewTransition: new <TElement extends keyof HTMLElementTagNameMap = "span">(props: import('./main').ViewTransitionProps<TElement>) => import('vue').ComponentPublicInstance<import('./main').ViewTransitionProps<TElement>>;
+/**
+ * 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 +183,25 @@ export declare const useLink: RouterAssets<RegisteredRouter>['useLink'];
  * @group Compositions
  */
 export declare const useRejection: RouterAssets<RegisteredRouter>['useRejection'];
+/**
+ * A composition to access the view transition in flight, if any.
+ *
+ * @returns The router's view transition state.
+ * @group Compositions
+ */
+export declare const useViewTransition: RouterAssets<RegisteredRouter>['useViewTransition'];
+/**
+ * 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/addView.d.ts

@@ -1,6 +1,6 @@
 import { Component } from 'vue';
 import { AnyPayloadTransformer } from './payload';
-import { PropsGetter } from '../types/createRouteOptions';
+import { AddViewPropsGetter } from '../types/addView';
 import { PrefetchConfig } from '../types/prefetch';
 import { CreatedRouteOptions, Route } from '../types/route';
 /**
@@ -9,7 +9,7 @@ import { CreatedRouteOptions, Route } from '../types/route';
  */
 type ViewOptions = {
     name?: string;
-    props?: PropsGetter;
+    props?: AddViewPropsGetter<Route, Component>;
     prefetch?: PrefetchConfig;
     transformer?: AnyPayloadTransformer;
 };
@@ -25,7 +25,7 @@ export type AddView = (...args: AddViewParameters) => Route;
 type View = {
     name: string;
     component: Component;
-    props: PropsGetter | undefined;
+    props: AddViewPropsGetter<Route, Component> | undefined;
     prefetch: PrefetchConfig | undefined;
     transformer: AnyPayloadTransformer | undefined;
 };

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/createRoute.d.ts

@@ -1,5 +1,3 @@
-import { CreateRouteOptions, PropsGetter, CreateRouteProps, ToRouteMatches, ToRouteUrl, RouterViewPropsGetter } from '../types/createRouteOptions';
+import { CreateRouteOptions, ToRouteMatches, ToRouteUrl } from '../types/createRouteOptions';
 import { RouteWithMethods } from '../types/routeWithMethods';
-type CreateRouteWithProps<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions>> = CreateRouteProps<TOptions> extends RouterViewPropsGetter<TOptions> ? [props?: RouterViewPropsGetter<TOptions>] : CreateRouteProps<TOptions> extends PropsGetter<TOptions> ? Partial<ReturnType<CreateRouteProps<TOptions>>> extends ReturnType<CreateRouteProps<TOptions>> ? [props?: TProps] : [props: TProps] : Partial<CreateRouteProps<TOptions>> extends CreateRouteProps<TOptions> ? [props?: TProps] : [props: TProps];
-export declare function createRoute<const TOptions extends CreateRouteOptions, const TProps extends CreateRouteProps<TOptions>>(options: TOptions, ...args: CreateRouteWithProps<TOptions, TProps>): RouteWithMethods<ToRouteUrl<TOptions>, ToRouteMatches<TOptions, TProps>>;
-export {};
+export declare function createRoute<const TOptions extends CreateRouteOptions>(options: TOptions): RouteWithMethods<ToRouteUrl<TOptions>, ToRouteMatches<TOptions>>;

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/createRouter.d.ts

@@ -17,8 +17,8 @@ import { EmptyRouterPlugin, RouterPlugin } from '../types/routerPlugin';
  * const About = { template: '<div>About</div>' }
  *
  * export const routes = [
- *   createRoute({ name: 'home', path: '/', component: Home }),
- *   createRoute({ name: 'path', path: '/about', component: About }),
+ *   createRoute({ name: 'home', path: '/' }).addView(Home),
+ *   createRoute({ name: 'path', path: '/about' }).addView(About),
  * ] as const
  *
  * const router = createRouter(routes)

package/dist/services/createRouterAssets.d.ts

@@ -1,7 +1,9 @@
+import { ViewTransition } from '../components/viewTransition';
 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 +11,8 @@ import { createUseLink } from '../compositions/useLink';
 import { createIsRoute } from '../guards/routes';
 import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../types/hooks';
 import { createUseRejection } from '../compositions/useRejection';
+import { createUseViewTransition } from '../compositions/useViewTransition';
+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 +74,17 @@ export type RouterAssets<TRouter extends Router> = {
      * @group Components
      */
     RouterLink: ReturnType<typeof createRouterLink<TRouter>>;
+    /** Names a shared element for a view transition. @group Components */
+    ViewTransition: typeof ViewTransition;
+    /**
+     * 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 +136,21 @@ export type RouterAssets<TRouter extends Router> = {
      * @group Compositions
      */
     useRejection: ReturnType<typeof createUseRejection<TRouter>>;
+    /**
+     * A composition to access the view transition in flight, if any.
+     *
+     * @returns The router's view transition state.
+     * @group Compositions
+     */
+    useViewTransition: ReturnType<typeof createUseViewTransition<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/createRouterHistory.d.ts

@@ -1,4 +1,4 @@
-import { History, Listener } from './history';
+import { History, Update } from './history';
 type NavigationPushOptions = {
     replace?: boolean;
     state?: unknown;
@@ -12,8 +12,16 @@ type RouterHistory = History & {
     stopListening: () => void;
 };
 export type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
+/** Called by the router while the traversal navigation is active. */
+export type RouterHistoryTraversal = {
+    commit: () => void;
+    restore: () => void;
+};
+type RouterHistoryUpdate = Update & {
+    traversal?: RouterHistoryTraversal;
+};
 type RouterHistoryOptions = {
-    listener: Listener;
+    listener: (event: RouterHistoryUpdate) => void;
     mode?: RouterHistoryMode;
 };
 export declare function createRouterHistory({ mode, listener }: RouterHistoryOptions): RouterHistory;

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/createViewTransitions.browser.spec.d.ts

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

package/dist/services/createViewTransitions.d.ts

@@ -0,0 +1,38 @@
+import { ResolvedRoute } from '../types/resolved';
+import { RouterViewTransition, ViewTransitionTypes } from '../types/viewTransition';
+export type PendingViewTransition = {
+    to: ResolvedRoute;
+    from: ResolvedRoute;
+    types: ViewTransitionTypes;
+};
+export type ViewTransitions = {
+    /**
+     * The transition in flight, as the router exposes it.
+     */
+    viewTransition: RouterViewTransition;
+    /**
+     * Records the navigation about to transition, ahead of its data loading, so the page being left can
+     * prepare before it is captured.
+     */
+    prepare: (navigation: PendingViewTransition) => void;
+    /**
+     * Forgets a prepared navigation that was superseded before it transitioned, unless a newer one has
+     * taken over the state since.
+     */
+    cancel: (navigation: PendingViewTransition) => void;
+    /**
+     * Forgets the transition in flight, for a navigation that commits without one.
+     */
+    reset: () => void;
+    /**
+     * Runs the update inside a view transition. Resolves after the update and Vue flush, ahead of the animation.
+     */
+    start: (update: () => void | Promise<unknown>) => Promise<void>;
+};
+/**
+ * Owns the one transition the document runs at a time. Starting another while the first has not yet run
+ * its callback leaves the browser free to run the two callbacks in either order, so a navigation arriving
+ * then takes over the pending callback instead. Once the callback has run the browser skips the old
+ * animation on its own.
+ */
+export declare function createViewTransitions(): ViewTransitions;

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/history.d.ts

@@ -23,6 +23,7 @@ export interface Transition extends Update {
 export type Blocker = (tx: Transition) => void;
 export type To = string | Partial<Path>;
 export interface History {
+    readonly index: number | null;
     readonly action: Action;
     readonly location: Location;
     createHref: (to: To) => 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/routeViews.d.ts

@@ -0,0 +1,7 @@
+import { RouteViews } from '../types/routeViews';
+export declare const DEFAULT_VIEW_NAME = "default";
+/**
+ * The names of the views that have a props getter. A view without one is never computed, so waiting on it
+ * would never settle.
+ */
+export declare function viewNamesWithProps(views: RouteViews): string[];

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/navigationBehavior.browser.spec.d.ts

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

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

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

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

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