@kitbag/router 0.24.3 → 0.25.0

package/dist/{src/main.d.ts → main.d.ts}

@@ -1,6 +1,11 @@
 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 { RouteAddView, AddViewOptions, AddViewPropsGetter, AddViewPropsCallbackContext } from './types/addView';
+export type { RouteAddLoader, AddLoaderOptions, LoaderGetter } from './types/addLoader';
+export type { RouteCallbackContext } from './types/routeCallbackContext';
+export type { RouteViews } from './types/routeViews';
+export type { RouteLoader, RouteLoaders } from './types/routeLoaders';
 export type { RejectionHooks, HookRemove, BeforeHookLifecycle, AfterHookLifecycle, HookLifecycle, BeforeEnterHookContext, BeforeEnterHook, AddBeforeEnterHook, BeforeUpdateHookContext, BeforeUpdateHook, AddBeforeUpdateHook, BeforeLeaveHookContext, BeforeLeaveHook, AddBeforeLeaveHook, AfterEnterHookContext, AfterEnterHook, AddAfterEnterHook, AfterUpdateHookContext, AfterUpdateHook, AddAfterUpdateHook, AfterLeaveHookContext, AfterLeaveHook, AddAfterLeaveHook, RejectionHookContext, RejectionHook, AddRejectionHook, ErrorHookContext, ErrorHook, AddErrorHook } from './types/hooks';
 export * from './types/paramTypes';
 export * from './types/prefetch';
@@ -26,7 +31,10 @@ export * from './types/urlString';
 export type { Url, CreateUrlOptions, ParseUrlOptions } from './types/url';
 export * from './types/useLink';
 export { DuplicateParamsError } from './errors/duplicateParamsError';
+export { LoaderDataAccessError } from './errors/loaderDataAccessError';
+export { LoaderNameConflict } from './errors/loaderNameConflict';
 export { MetaPropertyConflict } from './errors/metaPropertyConflict';
+export { NavigationAbandonedError } from './errors/navigationAbandonedError';
 export { RouterNotInstalledError } from './errors/routerNotInstalledError';
 export { UseRouteInvalidError } from './errors/useRouteInvalidError';
 export { createRoute } from './services/createRoute';

package/dist/services/addLoader.d.ts

@@ -0,0 +1,40 @@
+import { PrefetchConfig } from '../types/prefetch';
+import { CreatedRouteOptions, Route } from '../types/route';
+import { AnyFunction } from '../types/utilities';
+export declare const DEFAULT_LOADER_NAME = "default";
+/**
+ * The loose runtime shape of the `addLoader` options. Purposely wide: the name type each
+ * `RouteAddLoader` describes is refined per route.
+ */
+type LoaderOptions = {
+    name?: string;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The runtime arguments accepted by `addLoader`.
+ */
+type AddLoaderParameters = [load: AnyFunction, options?: LoaderOptions];
+/**
+ * The loose runtime signature of the `addLoader` method. Purposely wide: it returns Route rather than the
+ * refined chainable route each `RouteAddLoader` overload describes.
+ */
+export type AddLoader = (...args: AddLoaderParameters) => Route;
+type Loader = {
+    name: string;
+    load: AnyFunction;
+    prefetch: PrefetchConfig | undefined;
+};
+export declare function toLoader(load: AnyFunction, options: LoaderOptions | undefined): Loader;
+/**
+ * Returns a new match with the loader merged into its loaders under the loader's name.
+ *
+ * Matches are `markRaw` so that making a route reactive does not turn its loaders into reactive proxies.
+ * Spreading a match drops that, so the rebuilt one is marked again.
+ */
+export declare function addLoaderToMatch(match: CreatedRouteOptions, { name, load, prefetch }: Loader): CreatedRouteOptions;
+/**
+ * A route's data combines the loaders of every match, so a name an ancestor already uses would be
+ * ambiguous. Adding a loader the route itself already has is an override, and allowed.
+ */
+export declare function checkForLoaderConflict(ancestors: CreatedRouteOptions[], name: string): void;
+export {};

package/dist/services/addView.d.ts

@@ -0,0 +1,37 @@
+import { Component } from 'vue';
+import { PropsGetter } from '../types/createRouteOptions';
+import { PrefetchConfig } from '../types/prefetch';
+import { CreatedRouteOptions, Route } from '../types/route';
+/**
+ * The loose runtime shape of the `addView` options. Purposely wide: the getter and name types each
+ * `RouteAddView` describes are refined per route and component.
+ */
+type ViewOptions = {
+    name?: string;
+    props?: PropsGetter;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The runtime arguments accepted by `addView`.
+ */
+type AddViewParameters = [component: Component, options?: ViewOptions];
+/**
+ * The loose runtime signature of the `addView` method. Purposely wide: it returns Route rather than the
+ * refined chainable route each `RouteAddView` overload describes.
+ */
+export type AddView = (...args: AddViewParameters) => Route;
+type View = {
+    name: string;
+    component: Component;
+    props: PropsGetter | undefined;
+    prefetch: PrefetchConfig | undefined;
+};
+export declare function toView(component: Component, options: ViewOptions | undefined): View;
+/**
+ * Returns a new match with the view merged into its views under the view's name.
+ *
+ * Matches are `markRaw` so that making a route reactive does not turn its components into reactive
+ * proxies. Spreading a match drops that, so the rebuilt one is marked again.
+ */
+export declare function addViewToMatch(match: CreatedRouteOptions, { name, component, props, prefetch }: View): CreatedRouteOptions;
+export {};

package/dist/{src/services → services}/component.d.ts

@@ -1,12 +1,11 @@
 import { AsyncComponentLoader, Component, FunctionalComponent, InjectionKey } from 'vue';
-import { CreatedRouteOptions } from '../types/route';
 import { Router } from '../types/router';
 type Constructor = new (...args: any) => any;
 export type ComponentProps<TComponent extends Component> = TComponent extends Constructor ? InstanceType<TComponent>['$props'] : TComponent extends AsyncComponentLoader<infer T extends Component> ? ComponentProps<T> : TComponent extends FunctionalComponent<infer T> ? T : {};
 type CreateComponentWrapperConfig = {
-    match: CreatedRouteOptions;
+    id: string;
     name: string;
     component: Component;
 };
-export declare function createComponentPropsWrapper(routerKey: InjectionKey<Router>, { match, name, component }: CreateComponentWrapperConfig): Component;
+export declare function createComponentPropsWrapper(routerKey: InjectionKey<Router>, { id, name, component }: CreateComponentWrapperConfig): Component;
 export {};

package/dist/{src/services → services}/createComponentsStore.d.ts

@@ -1,7 +1,7 @@
 import { Component, InjectionKey } from 'vue';
-import { CreatedRouteOptions } from '../types/route';
+import { RouteViews } from '../types/routeViews';
 import { Router } from '../types/router';
 export type ComponentsStore = {
-    getRouteComponents: (match: CreatedRouteOptions) => Record<string, Component>;
+    getRouteComponents: (id: string, views: RouteViews) => Record<string, Component>;
 };
 export declare function createComponentsStore<TRouter extends Router>(routerKey: InjectionKey<TRouter>): ComponentsStore;

package/dist/services/createCurrentRoute.d.ts

@@ -0,0 +1,25 @@
+import { InjectionKey } from 'vue';
+import { RouteValueStore } from './createRouteValueStore';
+import { Router, RouterRouteUnion } from '../types/router';
+import { ResolvedRoute, WithData } from '../types/resolved';
+import { Routes } from '../types/route';
+import { RouterPush } from '../types/routerPush';
+type ResolvedRouteUpdate = (route: ResolvedRoute) => void;
+type CurrentRouteContext<TRoutes extends Routes = Routes> = {
+    currentRoute: ResolvedRoute & WithData;
+    routerRoute: RouterRouteUnion<TRoutes>;
+    updateRoute: ResolvedRouteUpdate;
+};
+type CurrentRouteOptions = {
+    routerKey: InjectionKey<Router>;
+    fallbackRoute: ResolvedRoute;
+    push: RouterPush;
+    getData: RouteValueStore['getData'];
+};
+/**
+ * The route the router is on. Data is read from the store as a route becomes current, which is the only
+ * route whose data anything computes — so a caller hands over whatever it resolved and does not have to
+ * know that data is attached at all.
+ */
+export declare function createCurrentRoute<TRoutes extends Routes>(options: CurrentRouteOptions): CurrentRouteContext<TRoutes>;
+export {};

package/dist/services/createDataStore.d.ts

@@ -0,0 +1,48 @@
+export type DataResultValue = {
+    kind: 'value';
+    value: unknown;
+};
+export type DataResultError = {
+    kind: 'error';
+    error: unknown;
+};
+export type DataResultPending = {
+    kind: 'pending';
+};
+export type DataResultRunning = {
+    kind: 'running';
+};
+export type DataResultMissing = {
+    kind: 'missing';
+};
+/**
+ * Where a key has got to: nothing has asked for it, something is waiting on it, its getter is in flight,
+ * or how that getter settled. Tagged so that a getter returning `undefined` or an `Error` stays a value.
+ */
+export type DataResult = DataResultValue | DataResultError | DataResultPending | DataResultRunning | DataResultMissing;
+/**
+ * A set of values that live and die together. A link owns one for whatever it points at, and the current
+ * navigation owns one.
+ */
+export type DataStore = {
+    /**
+     * The value for a key, whether or not anything has computed it yet. Subscribing to a key nobody has set
+     * leaves a promise waiting for whoever does.
+     */
+    subscribe: (key: string) => Promise<unknown>;
+    /**
+     * Computes a key, unless something already has. A key promoted from another store while its getter is
+     * still running is left alone, so navigation adopts it rather than computing it a second time.
+     */
+    set: (key: string, getter: () => unknown) => void;
+    /**
+     * What is known about a key, without waiting for it. Reactive, and readable during render.
+     */
+    get: (key: string) => DataResult;
+    /**
+     * Ends the store. Every value is rejected so that anything waiting on one resumes rather than staying
+     * suspended, then discarded.
+     */
+    dispose: (reason: Error) => void;
+};
+export declare function createDataStore(): DataStore;

package/dist/services/createNavigationStores.d.ts

@@ -0,0 +1,31 @@
+import { DataStore } from './createDataStore';
+import { ResolvedRoute } from '../types/resolved';
+/**
+ * Which store the rendered route reads from, and which one the next navigation will adopt.
+ *
+ * A navigation gets its own store so the one it replaces can be disposed outright. A followed link stages
+ * the store it prefetched into, which the navigation it triggers picks up — staged rather than handed over
+ * directly because a link is followed before that navigation starts.
+ */
+export type NavigationStores = {
+    /**
+     * The store the rendered route reads props from.
+     */
+    current: () => DataStore;
+    /**
+     * Parks a followed link's store for the navigation it triggered. A store already parked is disposed,
+     * since following a second link before the first navigation arrives abandons the first.
+     */
+    stage: (store: DataStore) => void;
+    /**
+     * Swaps in the staged store, or a fresh one, and hands back the store being replaced for disposal.
+     */
+    promote: () => DataStore;
+};
+export declare function createNavigationStores(): NavigationStores;
+/**
+ * What a stored value is: the props of a view, or the data of a loader. Part of the key so that a view
+ * and a loader sharing a name on the same route are still two values.
+ */
+export type DataKind = 'props' | 'loader';
+export declare function getDataKey(kind: DataKind, id: string, name: string, route: ResolvedRoute): string;

package/dist/{src/services → services}/createRoute.d.ts

@@ -1,8 +1,5 @@
-import { CreateRouteOptions, PropsGetter, CreateRouteProps, ToRoute, RouterViewPropsGetter } from '../types/createRouteOptions';
-import { InternalRouteHooks } from '../types/hooks';
-import { ExtractRouteContext } from '../types/routeContext';
-import { RouteRedirects } from '../types/redirects';
-import { RouteSetTitle } from '../types/routeTitle';
+import { CreateRouteOptions, PropsGetter, CreateRouteProps, ToRouteMatches, ToRouteUrl, RouterViewPropsGetter } 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>): ToRoute<TOptions, TProps> & InternalRouteHooks<ToRoute<TOptions>, ExtractRouteContext<TOptions>> & RouteRedirects<ToRoute<TOptions>> & RouteSetTitle<ToRoute<TOptions>>;
+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 {};

package/dist/services/createRouteValueStore.d.ts

@@ -0,0 +1,56 @@
+import { PrefetchConfigs, PrefetchStrategy } from '../types/prefetch';
+import { ResolvedRoute, WithData } from '../types/resolved';
+import { HasVueAppStore } from './createVueAppStore';
+import { CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from '../types/callbackContext';
+import { PropsResult } from '../utilities/props';
+import { MaybePromise } from '../types/utilities';
+/**
+ * A navigation that was superseded before its values settled. The navigation that replaced it owns the
+ * outcome, so this one reports that it went nowhere rather than a success it never had.
+ */
+type RouteValueAbandoned = {
+    status: 'ABANDONED';
+};
+export type RouteValueResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject | RouteValueAbandoned;
+/**
+ * How a navigation's props and loaders settled. Reported separately because props are what a view renders
+ * with while loaders hold nothing up, so a slow loader must not be what decides when props are known.
+ */
+export type RouteValueResponses = {
+    props: Promise<RouteValueResponse>;
+    loaders: Promise<RouteValueResponse>;
+};
+/**
+ * A link's own bucket of prefetched values, handed to the current navigation when the link is followed and
+ * discarded otherwise.
+ */
+export type PrefetchStore = {
+    /**
+     * Computes props for views whose prefetch option matches the given strategy.
+     */
+    prefetch: (strategy: PrefetchStrategy, route: ResolvedRoute, configs: PrefetchConfigs) => void;
+    /**
+     * Stages the prefetched store for the next navigation to adopt.
+     */
+    commit: () => void;
+    /**
+     * Abandons what was prefetched and starts over, for a link that now points somewhere else.
+     */
+    reset: () => void;
+    /**
+     * Abandons what was prefetched, for a link that is gone.
+     */
+    dispose: () => void;
+};
+export type RouteValueStore = HasVueAppStore & {
+    createPrefetchStore: () => PrefetchStore;
+    setRouteValues: (route: ResolvedRoute) => RouteValueResponses;
+    getProps: (id: string, name: string, route: ResolvedRoute) => MaybePromise<PropsResult>;
+    /**
+     * What a route exposes as `data`. Resolved per read rather than captured, so it stays correct as
+     * navigations replace the store its values live in.
+     */
+    getData: (route: ResolvedRoute) => WithData['data'];
+};
+export declare function createRouteValueStore(): RouteValueStore;
+export {};

package/dist/services/createRouteViews.d.ts

@@ -0,0 +1,16 @@
+import { CreateRouteOptions, CreateRouteProps } from '../types/createRouteOptions';
+import { RouteViews } from '../types/routeViews';
+export declare const DEFAULT_VIEW_NAME = "default";
+/**
+ * Builds the initial views for a route, seeding components from the (deprecated) `component`/`components`
+ * options and prop getters from the props argument. Subsequent views are added via the route's `addView`.
+ *
+ * This is where the props argument's two shapes — a single getter for the unnamed view, or a record keyed
+ * by view name — are normalized, so the rest of the router only deals with views keyed by name.
+ */
+export declare function createRouteViews(options: CreateRouteOptions, props?: CreateRouteProps): RouteViews;
+/**
+ * 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/{src/services → services}/createRouterRoute.d.ts

@@ -1,7 +1,7 @@
 import { InjectionKey } from 'vue';
-import { ResolvedRoute } from '../types/resolved';
+import { ResolvedRoute, WithData } from '../types/resolved';
 import { RouterRoute } from '../types/routerRoute';
 import { RouterPush } from '../types/routerPush';
 import { Router } from '../types/router';
 export declare function isRouterRoute(routerKey: InjectionKey<Router>, value: unknown): value is RouterRoute;
-export declare function createRouterRoute<TRoute extends ResolvedRoute>(routerKey: InjectionKey<Router>, route: TRoute, push: RouterPush): RouterRoute<TRoute>;
+export declare function createRouterRoute<TRoute extends ResolvedRoute & WithData>(routerKey: InjectionKey<Router>, route: TRoute, push: RouterPush): RouterRoute<TRoute>;

package/dist/{src/services → services}/getRoutesForRouter.d.ts

@@ -11,7 +11,6 @@ import { RouterOptions } from '../types/router';
 export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?: RouterPlugin[], options?: RouterOptions): {
     routes: (import('../main').Url & {
         id: string;
-        matched: import('../types/route').CreatedRouteOptions;
         matches: import('../types/route').CreatedRouteOptions[];
         name: string;
         meta: Record<string, unknown>;

package/dist/services/withRouteMethods.d.ts

@@ -0,0 +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.
+ */
+export declare function withRouteMethods<TRoute extends Route>(route: TRoute): TRoute;

package/dist/types/addLoader.d.ts

@@ -0,0 +1,69 @@
+import { RouteWithMethods } from './routeWithMethods';
+import { PrefetchConfig } from './prefetch';
+import { ResolvedRoute } from './resolved';
+import { CreatedRouteOptions, Route } from './route';
+import { RouteCallbackContext } from './routeCallbackContext';
+import { RouteLoader, RouteLoaders } from './routeLoaders';
+import { Url } from './url';
+import { Identity, LastInArray } from './utilities';
+/**
+ * The getter for a loader added via `addLoader`. Receives the same two arguments as an `addView` props
+ * getter, except that its route carries no data: a route's data includes what the loader itself is
+ * computing, so reading it could only wait on itself. A parent's data is reached through the context.
+ *
+ * Unlike a props getter it can return anything, since nothing binds what it returns to a component.
+ */
+export type LoaderGetter<TRoute extends Route = Route> = (route: ResolvedRoute<TRoute>, context: RouteCallbackContext<TRoute>) => unknown;
+/**
+ * The options for a loader added via `addLoader`.
+ *
+ * @template TName - The loader's name, inferred from the `name` option.
+ */
+export type AddLoaderOptions<TName extends string | undefined = string> = {
+    /**
+     * The name of the loader, which is the key its data is exposed under on the route. Defaults to the
+     * unnamed loader, whose data is exposed as the route's data directly.
+     */
+    name?: TName;
+    /**
+     * Determines whether this loader is run when a router-link is rendered for this route. Overrides route
+     * level prefetch, and is itself overridden by link level prefetch.
+     */
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The loaders of the route itself, from the last `matches` entry.
+ */
+type CurrentMatchLoaders<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    loaders: infer TLoaders extends RouteLoaders;
+} ? TLoaders : RouteLoaders;
+/**
+ * Computes the new loaders after adding a loader, replacing any loader the route already stored under
+ * the same name.
+ */
+type AddLoaderLoaders<TCurrent extends RouteLoaders, TName extends string | undefined, TData> = Identity<Omit<TCurrent, LoaderName<TName>> & Record<LoaderName<TName>, RouteLoader<TData>>> extends infer TNext extends RouteLoaders ? TNext : TCurrent;
+type LoaderName<TName extends string | undefined> = TName extends string ? TName : 'default';
+/**
+ * Replaces the loaders on the last match, preserving all ancestors.
+ */
+type ReplaceLastMatchLoaders<TMatches extends CreatedRouteOptions[], TNewLoaders extends RouteLoaders> = TMatches extends [...infer THead extends CreatedRouteOptions[], infer TLast extends CreatedRouteOptions] ? Identity<Omit<TLast, 'loaders'> & {
+    loaders: TNewLoaders;
+}> extends infer TNext extends CreatedRouteOptions ? [...THead, TNext] : TMatches : TMatches;
+/**
+ * The full return type of an `addLoader` call: the same url with the last match's loaders replaced.
+ */
+type AddLoaderReturn<TUrl extends Url, TMatches extends CreatedRouteOptions[], TNewLoaders extends RouteLoaders> = ReplaceLastMatchLoaders<TMatches, TNewLoaders> extends infer TNext extends CreatedRouteOptions[] ? RouteWithMethods<TUrl, TNext> : never;
+/**
+ * Adds a loader to a route. Chainable to register multiple loaders, each exposed under its own name on
+ * the resolved route's `data`.
+ */
+export type RouteAddLoader<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = {
+    /**
+     * Adds a loader for this route. Loaders never block rendering, so their data is always a promise.
+     *
+     * @param load - The loader callback. Receives the resolved route and a context object.
+     * @param options - The loader's `name` and `prefetch` config.
+     */
+    addLoader: <const TName extends string | undefined = undefined, const TGetter extends LoaderGetter<Route<TUrl, TMatches>> = LoaderGetter<Route<TUrl, TMatches>>>(load: TGetter, options?: AddLoaderOptions<TName>) => AddLoaderReturn<TUrl, TMatches, AddLoaderLoaders<CurrentMatchLoaders<TMatches>, TName, ReturnType<TGetter>>>;
+};
+export {};

package/dist/types/addView.d.ts

@@ -0,0 +1,104 @@
+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';
+import { RouteWithMethods } from './routeWithMethods';
+import { PrefetchConfig } from './prefetch';
+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.
+ */
+export type AddViewPropsGetter<TRoute extends Route, TComponent extends Component> = (route: ResolvedRoute<TRoute> & WithData<TRoute>, context: AddViewPropsCallbackContext<TRoute>) => MaybePromise<ComponentProps<TComponent>>;
+/**
+ * Context provided to an `addView` props getter. The same context a loader is given, since both are
+ * callbacks attached to a route.
+ */
+export type AddViewPropsCallbackContext<TRoute extends Route> = RouteCallbackContext<TRoute>;
+/**
+ * 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
+ * view only needs what the props resolve to, not the signature it took to get there.
+ */
+type NewViewProps<TRoute extends Route, TComponent extends Component, TGetter extends AnyFunction> = AddViewPropsGetter<TRoute, TComponent> extends TGetter ? undefined : ReturnType<TGetter>;
+/**
+ * The options for a view added via `addView`.
+ *
+ * @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> = {
+    /**
+     * The name of the view, rendered by `<router-view name="..." />`. Defaults to the unnamed view.
+     */
+    name?: TName;
+    /**
+     * A props getter for the view. Receives the resolved route and a context object.
+     */
+    props?: TGetter;
+    /**
+     * Determines what assets are prefetched for this view when a router-link is rendered for this route.
+     * Overrides route level prefetch, and is itself overridden by link level prefetch.
+     */
+    prefetch?: PrefetchConfig;
+};
+/**
+ * {@link AddViewOptions} with `props` promoted to required. Only reached for components that have
+ * required props — everything else uses {@link AddViewOptions}, where `props` stays optional, so a view
+ * can always be given a name and a prefetch config without a getter.
+ *
+ * Spelled out rather than intersected with {@link AddViewOptions} so that the literal `name` still
+ * infers through the conditional args tuple.
+ */
+type AddViewOptionsWithRequiredProps<TName extends string | undefined, TGetter> = {
+    name?: TName;
+    props: TGetter;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The options argument for `addView`, required only when the component has required props. `TName` and
+ * `TGetter` are inferred from the object's properties rather than from the object as a whole: inferring
+ * the whole object as a `const` type param through this conditional tuple widens the literal name.
+ */
+type AddViewArgs<TComponent extends Component, TName extends string | undefined, TGetter> = ComponentPropsAreOptional<TComponent> extends true ? [options?: AddViewOptions<TName, TGetter>] : [options: AddViewOptionsWithRequiredProps<TName, TGetter>];
+/**
+ * The views of the route itself, from the last `matches` entry.
+ */
+type CurrentMatchViews<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    views: infer TViews extends RouteViews;
+} ? TViews : RouteViews;
+/**
+ * Computes the new views after adding a view, replacing any view already stored under the same name.
+ */
+export type AddViewProps<TCurrent extends RouteViews, TName extends string | undefined, TNewProps> = Identity<Omit<TCurrent, ViewName<TName>> & Record<ViewName<TName>, [TNewProps] extends [undefined] ? RouteView : RouteView<TNewProps>>> extends infer TNext extends RouteViews ? TNext : TCurrent;
+type ViewName<TName extends string | undefined> = TName extends string ? TName : 'default';
+/**
+ * Replaces the views on the last match, preserving all ancestors.
+ */
+type ReplaceLastMatchViews<TMatches extends CreatedRouteOptions[], TNewViews extends RouteViews> = TMatches extends [...infer THead extends CreatedRouteOptions[], infer TLast extends CreatedRouteOptions] ? Identity<Omit<TLast, 'views'> & {
+    views: TNewViews;
+}> extends infer TNext extends CreatedRouteOptions ? [...THead, TNext] : TMatches : TMatches;
+/**
+ * The full return type of an `addView` call: the same url with the last match's views replaced.
+ */
+type AddViewReturn<TUrl extends Url, TMatches extends CreatedRouteOptions[], TNewProps extends RouteViews> = ReplaceLastMatchViews<TMatches, TNewProps> extends infer TNext extends CreatedRouteOptions[] ? RouteWithMethods<TUrl, TNext> : never;
+/**
+ * Adds a view (component + optional props getter) to a route. Chainable to register multiple views,
+ * including named views for named `<router-view />`s.
+ */
+export type RouteAddView<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = {
+    /**
+     * Adds a view for this route.
+     *
+     * @param component - The component to render. Rendered by `<router-view name="..." />` when the
+     * options carry a name, and by the default `<router-view />` otherwise.
+     * @param options - The view's `name`, `props` getter, and `prefetch` config. Required when the
+     * component has required props, optional otherwise.
+     */
+    addView: <TComponent extends Component, const TName extends string | undefined = undefined, const TGetter extends AddViewPropsGetter<Route<TUrl, TMatches>, TComponent> = AddViewPropsGetter<Route<TUrl, TMatches>, TComponent>>(component: TComponent, ...options: AddViewArgs<TComponent, TName, TGetter>) => AddViewReturn<TUrl, TMatches, AddViewProps<CurrentMatchViews<TMatches>, TName, NewViewProps<Route<TUrl, TMatches>, TComponent, TGetter>>>;
+};
+export {};