@kitbag/router 0.24.3 → 0.25.0

package/dist/{src/types → types}/createRouteOptions.d.ts

@@ -1,22 +1,20 @@
 import { Component } from 'vue';
-import { CombineMeta } from '../services/combineMeta';
-import { CombineState } from '../services/combineState';
 import { Param } from './paramTypes';
 import { PrefetchConfig } from './prefetch';
 import { RouteMeta } from './register';
 import { Route } from './route';
-import { ResolvedRoute } from './resolved';
+import { ResolvedRoute, WithData } from './resolved';
 import { ComponentProps } from '../services/component';
 import { PropsCallbackContext } from './props';
-import { Identity, MaybePromise } from './utilities';
+import { AnyFunction, Identity, MaybePromise } from './utilities';
 import { ToMeta } from './meta';
-import { ToState } from './state';
 import { ToName } from './name';
 import { UrlPart, UrlQueryPart } from '../services/withParams';
-import { RouteContext, ToRouteContext } from './routeContext';
+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.
@@ -44,15 +42,9 @@ type WithoutComponents = {
 export declare function isWithComponent<T extends Record<string, unknown>>(options: T): options is T & {
     component: Component;
 };
-export declare function isWithComponentProps<T extends Record<string, unknown>>(options: T): options is T & {
-    props: PropsGetter;
-};
 export declare function isWithComponents<T extends Record<string, unknown>>(options: T): options is T & {
     components: Record<string, Component>;
 };
-export declare function isWithComponentPropsRecord<T extends Record<string, unknown>>(options: T): options is T & {
-    props: RoutePropsRecord;
-};
 export type CreateRouteOptions<TName extends string | undefined = string | undefined, TMeta extends RouteMeta = RouteMeta> = {
     /**
      * Name for route, used to create route keys and in navigation.
@@ -90,10 +82,13 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      * 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>;
     /**
@@ -105,32 +100,58 @@ 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>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<ComponentProps<TComponent>>;
-export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
-type ComponentPropsAreOptional<TComponent extends Component> = Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? true : false;
+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> = Omit<TOptions, 'props' | 'meta' | 'name'> & {
+type ToMatch<TOptions extends CreateRouteOptions, TProps = undefined> = Omit<TOptions, 'meta' | 'name' | 'component' | 'components' | 'parent'> & {
     id: string;
     name: ToName<TOptions['name']>;
-    props: TProps;
     /**
      * Represents additional metadata associated with a route. Always present, defaults to empty object.
      */
     meta: ToMeta<TOptions['meta']>;
+    /**
+     * The views this route renders, keyed by view name.
+     */
+    views: PropsToViews<TProps>;
+    /**
+     * The loaders this route runs, keyed by loader name. Always empty here — loaders are only added via
+     * the route's `addLoader`.
+     */
+    loaders: {};
 };
-type ToMatches<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = TOptions extends {
+/**
+ * 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 {
     parent: infer TParent extends Route;
-} ? [...TParent['matches'], ToMatch<TOptions, TProps>] : [ToMatch<Identity<TOptions & WithoutComponents>, TProps>];
-export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined = undefined> = CreateRouteOptions extends TOptions ? Route : TOptions extends {
+} ? [...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]>>;
+} : {};
+/**
+ * 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;
-} ? Route<ToName<TOptions['name']>, TOptions['hoist'] extends true ? ToUrl<TOptions & WithoutComponents> : CombineUrl<TParent, ToUrl<TOptions & WithoutComponents>>, CombineMeta<ToMeta<TParent['meta']>, ToMeta<TOptions['meta']>>, CombineState<ToState<TParent['state']>, ToState<TOptions['state']>>, ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>, [
-    ...ToRouteContext<TParent['context']>,
-    ...ToRouteContext<TOptions['context']>
-]> : Route<ToName<TOptions['name']>, ToUrl<Identity<TOptions & WithoutComponents>>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>, ToRouteContext<TOptions['context']>>;
+} ? TOptions['hoist'] extends true ? ToUrl<TOptions & WithoutComponents> : CombineUrl<TParent, ToUrl<TOptions & WithoutComponents>> : ToUrl<Identity<TOptions & WithoutComponents>>;
+/**
+ * The matches for a route, with the props argument resolved to the views of its own match.
+ */
+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 {};

package/dist/{src/types → types}/hooks.d.ts

@@ -150,7 +150,7 @@ export type RejectionHookRunner<TRejection extends Rejection = Rejection, TRoute
 export type ErrorHookContext<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     to: RouterResolvedRouteUnion<TRoutes>;
     from: RouterResolvedRouteUnion<TRoutes> | null;
-    source: 'props' | 'hook' | 'component';
+    source: 'props' | 'loader' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
@@ -161,7 +161,7 @@ export type AddErrorHook<TRoute extends Route = Route, TRoutes extends Routes =
 export type ErrorHookRunnerContext<TRoutes extends Routes = Routes> = {
     to: RouterResolvedRouteUnion<TRoutes>;
     from: RouterResolvedRouteUnion<TRoutes> | null;
-    source: 'props' | 'hook';
+    source: 'props' | 'loader' | 'hook';
 };
 export type ErrorHookRunner = (error: unknown, context: ErrorHookRunnerContext) => void;
 export {};

package/dist/{src/types → types}/prefetch.d.ts

@@ -23,5 +23,6 @@ export type PrefetchConfig = boolean | PrefetchStrategy | PrefetchConfigOptions;
 export type PrefetchConfigs = {
     routerPrefetch?: PrefetchConfig;
     routePrefetch?: PrefetchConfig;
+    viewPrefetch?: PrefetchConfig;
     linkPrefetch?: PrefetchConfig;
 };

package/dist/{src/types → types}/props.d.ts

@@ -1,4 +1,4 @@
-import { CreateRouteOptions, PropsGetter } from './createRouteOptions';
+import { CreateRouteOptions } from './createRouteOptions';
 import { Route } from './route';
 import { RouterReject } from './routerReject';
 import { RouterPush } from './routerPush';
@@ -6,6 +6,9 @@ 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
  */
@@ -19,11 +22,16 @@ export type PropsCallbackContext<TRoute extends Route = Route, TOptions extends
 export type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
     name: string;
     props: unknown;
+    data: unknown;
 } : TParent extends Route ? {
     name: TParent['name'];
     props: GetParentPropsReturnType<TParent>;
+    data: GetParentDataReturnType<TParent>;
 } : undefined;
-type GetParentPropsReturnType<TParent extends Route | undefined = Route | undefined> = TParent extends Route ? TParent['matched']['props'] extends PropsGetter ? ReturnType<TParent['matched']['props']> : TParent['matched']['props'] extends Record<string, PropsGetter> ? {
-    [K in keyof TParent['matched']['props']]: ReturnType<TParent['matched']['props'][K]>;
-} : undefined : undefined;
+type GetParentPropsReturnType<TParent extends Route | undefined = Route | undefined> = TParent extends Route ? LastInArray<TParent['matches']> extends {
+    views: infer TViews;
+} ? ViewsPropsReturnType<TViews> : undefined : undefined;
+type GetParentDataReturnType<TParent extends Route | undefined = Route | undefined> = TParent extends Route ? LastInArray<TParent['matches']> extends {
+    loaders: infer TLoaders;
+} ? LoadersDataReturnType<TLoaders> : undefined : undefined;
 export {};

package/dist/{src/types → types}/resolved.d.ts

@@ -1,7 +1,13 @@
-import { Route, Routes } from './route';
+import { CreatedRouteOptions, Route, RouteDataOf, Routes } from './route';
+import { LastInArray } from './utilities';
 import { ExtractRouteStateParamsAsOptional } from './state';
 import { UrlString } from './urlString';
 import { UrlParamsReading } from './url';
+/**
+ * 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.
+ */
+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.
  * @template TRoute - Underlying Route that has been resolved.
@@ -14,7 +20,7 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
     /**
      * The specific route properties that were matched in the current route.
     */
-    matched: TRoute['matched'];
+    matched: MatchedRoute<TRoute['matches']>;
     /**
      * The specific route properties that were matched in the current route, including any ancestors.
      * Order of routes will be from greatest ancestor to narrowest matched.
@@ -49,6 +55,18 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      */
     title: Promise<string | undefined>;
 }>;
+/**
+ * A resolved route whose loaders' data is available. Only the route being navigated to has data: a route
+ * the router merely resolved is not being loaded, so data on it could never settle. The current route and
+ * a props getter's route have it, `router.resolve` and hooks do not.
+ */
+export type WithData<TRoute extends Route = Route> = {
+    /**
+     * What the route's loaders resolve to, keyed by loader name. A route whose only loader is unnamed
+     * exposes that loader's data here directly. Always promises, since loaders never block rendering.
+     */
+    data: RouteDataOf<TRoute['matches']>;
+};
 /**
  * This type is the same as `ResolvedRoute<TRoutes[number]>` while remaining distributive
  */
@@ -65,3 +83,4 @@ export type RouterResolvedRouteUnion<TRoutes extends Routes> = {
  * type ResolvedUnion = ResolvedRouteUnion<RouteUnion> // ResolvedRoute<RouteA> | ResolvedRoute<RouteB>
  */
 export type ResolvedRouteUnion<TRoute extends Route> = TRoute extends Route ? ResolvedRoute<TRoute> : never;
+export {};

package/dist/types/route.d.ts

@@ -0,0 +1,121 @@
+import { Param } from './paramTypes';
+import { PrefetchConfig } from './prefetch';
+import { RouteMeta } from './register';
+import { LastInArray } from './utilities';
+import { CreateRouteOptions } from './createRouteOptions';
+import { RouteContext, ToRouteContext } from './routeContext';
+import { ToMeta } from './meta';
+import { ToState } from './state';
+import { Url } from './url';
+import { GetRouteTitle } from './routeTitle';
+import { Hooks } from '../models/hooks';
+import { RouteRedirect } from './redirects';
+import { RouteViews } from './routeViews';
+import { LoadersDataReturnType, RouteLoaders } from './routeLoaders';
+export declare const IS_ROUTE_SYMBOL: unique symbol;
+export declare function isRoute(value: unknown): value is Route & RouteInternal;
+export type RouteInternal = {
+    [IS_ROUTE_SYMBOL]: true;
+    depth: number;
+    hooks: Hooks[];
+    redirect: RouteRedirect;
+    getTitle: GetRouteTitle;
+};
+/**
+ * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
+ */
+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}).
+ */
+export type CreatedRouteOptions = Omit<CreateRouteOptions, 'component' | 'components'> & {
+    id: string;
+    views: RouteViews;
+    loaders: RouteLoaders;
+};
+/**
+ * The name of the narrowest matched route.
+ */
+type RouteNameOf<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    name: infer TName extends string;
+} ? TName : string;
+/**
+ * The meta of every matched route, combined. Mirrors `combineMeta`, which is an intersection.
+ */
+type RouteMetaOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteMeta : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? ToMeta<THead extends {
+    meta: infer TMeta extends RouteMeta;
+} ? TMeta : undefined> & RouteMetaOf<TRest> : {};
+/**
+ * The state of every matched route, combined. Mirrors `combineState`, which is an intersection.
+ * A match without state contributes `{}` rather than `ToState<undefined>`, which widens to
+ * `Record<string, Param>` and would swallow the rest of the intersection.
+ */
+type RouteStateOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? Record<string, Param> : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? (THead extends {
+    state: infer TState extends Record<string, Param>;
+} ? ToState<TState> : {}) & RouteStateOf<TRest> : {};
+/**
+ * The loaders of every matched route, combined. A plain intersection: a loader name is unique across a
+ * route and its ancestors, which `addLoader` enforces.
+ */
+type RouteLoadersOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteLoaders : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? (THead extends {
+    loaders: infer TLoaders extends RouteLoaders;
+} ? TLoaders : {}) & RouteLoadersOf<TRest> : {};
+/**
+ * The data every matched route's loaders resolve to, which is what a resolved route exposes as `data`.
+ * Undefined when nothing in the route tree declares a loader.
+ */
+export type RouteDataOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? Promise<unknown> | Record<string, Promise<unknown>> | undefined : LoadersDataReturnType<RouteLoadersOf<TMatches>>;
+/**
+ * The context of every matched route, flattened from greatest ancestor to narrowest matched.
+ */
+type RouteContextOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteContext[] : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? [...ToRouteContext<THead extends {
+    context: infer TContext extends RouteContext[];
+} ? TContext : []>, ...RouteContextOf<TRest>] : [];
+/**
+ * Represents the structure of a route within the application. Return value of `createRoute`
+ * @template TUrl - The url the route resolves to, combined with any parents. Intersected into the route.
+ * @template TMatches - The options of the route and its ancestors, indexed by depth. Name, meta, state,
+ * and context are all derived from this, including each route's views.
+ */
+export type Route<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = TUrl & {
+    /**
+     * Unique identifier for the route, generated by router.
+    */
+    id: string;
+    /**
+     * The specific route properties that were matched in the current route, including any ancestors.
+     * Order of routes will be from greatest ancestor to narrowest matched.
+    */
+    matches: TMatches;
+    /**
+     * Identifier for the route as defined by user. Name must be unique among named routes. Name is used for routing and for matching.
+    */
+    name: RouteNameOf<TMatches>;
+    /**
+     * Represents additional metadata associated with a route, combined with any parents.
+    */
+    meta: RouteMetaOf<TMatches>;
+    /**
+     * Represents the schema of the route state, combined with any parents.
+    */
+    state: RouteStateOf<TMatches>;
+    /**
+     * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
+    */
+    prefetch?: PrefetchConfig;
+    /**
+     * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
+     */
+    context: RouteContextOf<TMatches>;
+};
+export type GenericRoute = Url & {
+    id: string;
+    name: string;
+    matches: CreatedRouteOptions[];
+    meta: RouteMeta;
+    state: Record<string, Param>;
+    prefetch?: PrefetchConfig;
+};
+export {};

package/dist/types/routeCallbackContext.d.ts

@@ -0,0 +1,30 @@
+import { ResolvedRoute } from './resolved';
+import { CreatedRouteOptions, Route } from './route';
+import { RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { RouterPush } from './routerPush';
+import { RouterReject } from './routerReject';
+import { RouterReplace } from './routerReplace';
+import { RouteUpdate } from './routeUpdate';
+import { LoadersDataReturnType } from './routeLoaders';
+import { ViewsPropsReturnType } from './routeViews';
+/**
+ * Context provided to a callback attached to a route — an `addView` props getter, or a loader. Sourced
+ * from the route: rejections/routes from the route's context, and the parent from the route's `matches`.
+ */
+export type RouteCallbackContext<TRoute extends Route> = {
+    reject: RouterReject<RouteContextToRejection<TRoute['context']>>;
+    push: RouterPush<[TRoute] | RouteContextToRoute<TRoute['context']>>;
+    replace: RouterReplace<[TRoute] | RouteContextToRoute<TRoute['context']>>;
+    update: RouteUpdate<ResolvedRoute<TRoute>>;
+    parent: RouteCallbackParent<TRoute>;
+};
+/**
+ * The parent context ({ name, props, data }) reconstructed from the second-to-last `matches` entry, which
+ * carries the parent's name, its views and its loaders.
+ */
+type RouteCallbackParent<TRoute extends Route> = TRoute['matches'] extends [...CreatedRouteOptions[], infer TParent extends CreatedRouteOptions, CreatedRouteOptions] ? {
+    name: TParent['name'];
+    props: ViewsPropsReturnType<TParent['views']>;
+    data: LoadersDataReturnType<TParent['loaders']>;
+} : undefined;
+export {};

package/dist/types/routeLoaders.d.ts

@@ -0,0 +1,30 @@
+import { PrefetchConfig } from './prefetch';
+import { AnyFunction } from './utilities';
+/**
+ * A single loader: how to load its data, and how to prefetch it. Unlike a view, a loader always has a
+ * getter — a loader without one would have nothing to contribute.
+ *
+ * @template TData - What this loader's getter returns, carried so a route's data can be typed from it.
+ */
+export type RouteLoader<TData = unknown> = {
+    load: AnyFunction<TData>;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The loaders for a single route, keyed by loader name (the unnamed loader under 'default').
+ */
+export type RouteLoaders = Record<string, RouteLoader>;
+/**
+ * The data a set of loaders resolves to. A lone unnamed loader is given directly rather than under a
+ * 'default' key, matching how the loader is written. Each loader's data is always a promise, since a
+ * loader never blocks rendering, even when the loader itself is synchronous.
+ */
+export type LoadersDataReturnType<TLoaders> = keyof TLoaders extends never ? undefined : keyof TLoaders extends 'default' ? LoaderData<Extract<TLoaders, {
+    default: unknown;
+}>['default']> : {
+    [K in keyof TLoaders]: LoaderData<TLoaders[K]>;
+};
+type LoaderData<TLoader> = TLoader extends {
+    load: AnyFunction<infer TData>;
+} ? Promise<Awaited<TData>> : never;
+export {};

package/dist/types/routeViews.d.ts

@@ -0,0 +1,44 @@
+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.
+ *
+ * @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;
+    props?: AnyFunction<TProps>;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * 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.
+ */
+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,
+ * 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>, {
+    default: unknown;
+}>['default']> : {
+    [K in keyof ViewsWithProps<TViews>]: ParentViewProps<ViewsWithProps<TViews>[K]>;
+};
+type ViewsWithProps<TViews> = {
+    [K in keyof TViews as HasViewProps<TViews[K]> extends true ? K : never]: TViews[K];
+};
+/**
+ * A view has props unless its getter is absent, which is carried as props resolving to undefined. Asked
+ * both ways because a getter that only ever throws resolves to never, which is assignable to undefined
+ * without being the absent case.
+ */
+type HasViewProps<TView> = [ViewProps<TView>] extends [undefined] ? [undefined] extends [ViewProps<TView>] ? false : true : true;
+type ViewProps<TView> = TView extends {
+    props?: AnyFunction<infer TProps>;
+} ? TProps : undefined;
+type ParentViewProps<TView> = Promise<Awaited<ViewProps<TView>>>;
+export {};

package/dist/types/routeWithMethods.d.ts

@@ -0,0 +1,16 @@
+import { RouteAddLoader } from './addLoader';
+import { RouteAddView } from './addView';
+import { InternalRouteHooks } from './hooks';
+import { RouteRedirects } from './redirects';
+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
+ * 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>>;

package/dist/{src/types → types}/routerPlugin.d.ts

@@ -49,7 +49,7 @@ type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejecti
 export type PluginErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     to: ResolvedRoute;
     from: ResolvedRoute | null;
-    source: 'props' | 'hook' | 'component';
+    source: 'props' | 'loader' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;

package/dist/{src/types → types}/routerRoute.d.ts

@@ -1,5 +1,6 @@
 import { RouteUpdate } from './routeUpdate';
 import { ResolvedRoute } from './resolved';
+import { RouteDataOf } from './route';
 import { QuerySource } from './querySource';
 export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
     /**
@@ -35,6 +36,11 @@ export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
      * Title of the route.
      */
     readonly title: TRoute['title'];
+    /**
+     * What the route's loaders resolve to, keyed by loader name. A route whose only loader is unnamed
+     * exposes that loader's data here directly.
+     */
+    readonly data: RouteDataOf<TRoute['matches']>;
     params: TRoute['params'];
     state: TRoute['state'];
     get query(): URLSearchParams;

package/dist/{src/types → types}/utilities.d.ts

@@ -4,6 +4,7 @@ export type Identity<T> = T extends object ? {} & {
 type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
 export type LastInArray<T, TFallback = never> = T extends [...any[], infer Last] ? Last : TFallback;
 export type MaybePromise<T> = T | Promise<T>;
+export type AnyFunction<TReturn = any> = (...args: any[]) => TReturn;
 type OnlyRequiredProperties<T> = {
     [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
 };

package/dist/utilities/checkDuplicateNames.spec.d.ts

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

package/dist/utilities/checkDuplicateParams.spec.d.ts

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

package/dist/utilities/components.spec.d.ts

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

package/dist/utilities/guards.spec.d.ts

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

package/dist/utilities/isBrowser.browser.spec.d.ts

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

package/dist/utilities/isBrowser.spec.d.ts

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

package/dist/{src/utilities → utilities}/prefetch.d.ts

@@ -1,4 +1,4 @@
 import { PrefetchConfig, PrefetchConfigOptions, PrefetchConfigs, PrefetchStrategy } from '../types/prefetch';
 export declare const DEFAULT_PREFETCH_STRATEGY: PrefetchStrategy;
-export declare function getPrefetchOption({ routerPrefetch, routePrefetch, linkPrefetch }: PrefetchConfigs, setting: keyof PrefetchConfigOptions): false | PrefetchStrategy;
+export declare function getPrefetchOption({ routerPrefetch, routePrefetch, viewPrefetch, linkPrefetch }: PrefetchConfigs, setting: keyof PrefetchConfigOptions): false | PrefetchStrategy;
 export declare function getPrefetchConfigValue(prefetch: PrefetchConfig | undefined, setting: keyof PrefetchConfigOptions): boolean | PrefetchStrategy | undefined;

package/dist/utilities/prefetch.spec.d.ts

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

package/dist/utilities/props.d.ts

@@ -0,0 +1,16 @@
+import { MaybePromise } from '../types/utilities';
+/**
+ * How a props getter settled. Tagged so that a getter returning `undefined` or an `Error` stays a value.
+ */
+export type PropsResult = {
+    kind: 'value';
+    value: unknown;
+} | {
+    kind: 'error';
+    error: unknown;
+};
+/**
+ * Runs a props callback and captures how it settled rather than letting it throw, so that navigation can
+ * tell a push or rejection apart from a genuine failure. Sync getters settle synchronously.
+ */
+export declare function getPropsValue(callback: () => unknown): MaybePromise<PropsResult>;