@kitbag/router 0.24.2 → 0.25.0

package/dist/services/getGlobalHooksForRouter.d.ts

@@ -0,0 +1,3 @@
+import { Hooks } from '../models/hooks';
+import { RouterPlugin } from '../types/routerPlugin';
+export declare function getGlobalHooksForRouter(plugins?: RouterPlugin[]): Hooks;

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

@@ -1,4 +1,4 @@
-import { ResolvedRoute } from '../../types/resolved';
-import { Hooks } from '../../models/hooks';
+import { ResolvedRoute } from '../types/resolved';
+import { Hooks } from '../models/hooks';
 export declare function getGlobalBeforeHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;
 export declare function getGlobalAfterHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;

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

@@ -1,6 +1,6 @@
-import { ResolvedRoute } from '../../types/resolved';
-import { Routes } from '../../types/route';
-import { ParseUrlOptions } from '../../types/url';
+import { ResolvedRoute } from '../types/resolved';
+import { Routes } from '../types/route';
+import { ParseUrlOptions } from '../types/url';
 type MatchOptions = {
     state?: Partial<unknown>;
 } & ParseUrlOptions;

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

@@ -1,3 +1,3 @@
-import { UrlParams } from '../../services/withParams';
-import { Param } from '../../types/paramTypes';
+import { UrlParams } from './withParams';
+import { Param } from '../types/paramTypes';
 export declare function getParamsForString(string?: string, params?: Record<string, Param | undefined>): UrlParams;

package/dist/services/getRejectionHooks.d.ts

@@ -0,0 +1,3 @@
+import { Hooks } from '../models/hooks';
+import { Rejection } from '../types/rejection';
+export declare function getRejectionHooksFromRejection(rejection: Rejection): Hooks;

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

@@ -1,4 +1,4 @@
-import { ResolvedRoute } from '../../types/resolved';
-import { Hooks } from '../../models/hooks';
+import { ResolvedRoute } from '../types/resolved';
+import { Hooks } from '../models/hooks';
 export declare function getBeforeHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): Hooks;
 export declare function getAfterHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): Hooks;

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

@@ -1,7 +1,7 @@
-import { Route, RouteInternal, Routes } from '../../types/route';
-import { RouterPlugin } from '../../types/routerPlugin';
-import { BuiltInRejectionType, Rejection, RejectionInternal } from '../../types/rejection';
-import { RouterOptions } from '../../types/router';
+import { Route, RouteInternal, Routes } from '../types/route';
+import { RouterPlugin } from '../types/routerPlugin';
+import { BuiltInRejectionType, Rejection, RejectionInternal } from '../types/rejection';
+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.
@@ -11,8 +11,7 @@ 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[];
+        matches: import('../types/route').CreatedRouteOptions[];
         name: string;
         meta: Record<string, unknown>;
         state: Record<string, import('../main').Param>;

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

@@ -1,5 +1,5 @@
-import { HookLifecycle } from '../../types/hooks';
-import { ResolvedRoute } from '../../types/resolved';
+import { HookLifecycle } from '../types/hooks';
+import { ResolvedRoute } from '../types/resolved';
 type RouteHookCondition = (to: ResolvedRoute, from: ResolvedRoute | null, depth: number) => boolean;
 export declare const isRouteEnter: RouteHookCondition;
 export declare const isRouteLeave: RouteHookCondition;

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

@@ -1,2 +1,2 @@
-import { Route } from '../../types/route';
+import { Route } from '../types/route';
 export declare function insertBaseRoute<T extends Route>(route: T, base?: string): T;

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

@@ -1,2 +1,2 @@
-import { LiteralParam, ParamGetSet } from '../../types/paramTypes';
+import { LiteralParam, ParamGetSet } from '../types/paramTypes';
 export declare function literal<T extends LiteralParam>(value: T): ParamGetSet<T>;

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

@@ -1,6 +1,6 @@
-import { UrlParam } from '../../services/withParams';
-import { ExtractParamType } from '../../types/params';
-import { Param } from '../../types/paramTypes';
+import { UrlParam } from './withParams';
+import { ExtractParamType } from '../types/params';
+import { Param } from '../types/paramTypes';
 export declare function getParam(params: Record<string, Param | undefined>, paramName: string): Param;
 export declare function getParamValue<T extends Param>(value: string | undefined, param: Partial<UrlParam<T>>): ExtractParamType<T>;
 export declare function safeGetParamValue<T extends Param>(value: string | undefined, param: Partial<UrlParam<T>>): ExtractParamType<T> | undefined;

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

@@ -1,2 +1,2 @@
-import { QuerySource } from '../../types/querySource';
+import { QuerySource } from '../types/querySource';
 export declare function filterQueryParams(source: QuerySource, exclude: QuerySource): URLSearchParams;

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

@@ -1,4 +1,4 @@
-import { UrlPart } from '../../services/withParams';
+import { UrlPart } from './withParams';
 export declare const paramRegex = "\\[\\??([\\w-_]+)\\*?\\]";
 export declare const optionalParamRegex = "\\[\\?([\\w-_]+)\\*?\\]";
 export declare const requiredParamRegex = "\\[([\\w-_]+)\\*?\\]";

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

@@ -1,4 +1,4 @@
-import { Param } from '../../types/paramTypes';
+import { Param } from '../types/paramTypes';
 /**
  * This function is used to get the values inside the state converted from string values into the correct type.
  */

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

@@ -1,5 +1,5 @@
-import { Param, ParamGetSet } from '../../types/paramTypes';
-import { ExtractParamType } from '../../types/params';
+import { Param, ParamGetSet } from '../types/paramTypes';
+import { ExtractParamType } from '../types/params';
 type TupleOfOptions = {
     separator?: string;
 };

package/dist/services/unionOf.d.ts

@@ -0,0 +1,3 @@
+import { Param, ParamGetSet } from '../types/paramTypes';
+import { ExtractParamType } from '../types/params';
+export declare function unionOf<const T extends Param[]>(params: T): ParamGetSet<ExtractParamType<T[number]>>;

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

@@ -1,5 +1,5 @@
-import { QuerySource } from '../../types/querySource';
-import { UrlString } from '../../types/urlString';
+import { QuerySource } from '../types/querySource';
+import { UrlString } from '../types/urlString';
 type UrlParts = {
     host?: string;
     path: string;

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

@@ -1,4 +1,4 @@
-import { Param, ParamGetSet } from '../../types/paramTypes';
+import { Param, ParamGetSet } from '../types/paramTypes';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 export interface ValibotSchemaLike extends StandardSchemaV1<any> {
     type: string;

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

@@ -1,5 +1,5 @@
-import { ExtractParamType } from '../../types/params';
-import { Param, ParamGetSet } from '../../types/paramTypes';
+import { ExtractParamType } from '../types/params';
+import { Param, ParamGetSet } from '../types/paramTypes';
 export type ParamWithDefault<TParam extends Param = Param> = Required<ParamGetSet<ExtractParamType<TParam>>>;
 export declare function isParamWithDefault(param: Param): param is ParamWithDefault;
 export declare function withDefault<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;

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

@@ -1,7 +1,7 @@
-import { ExtractParamName, ParamEnd, ParamIsGreedy, ParamIsOptionalOrHasDefault, ParamStart } from '../../types/params';
-import { Param } from '../../types/paramTypes';
-import { Identity } from '../../types/utilities';
-import { MakeOptional } from '../../utilities/makeOptional';
+import { ExtractParamName, ParamEnd, ParamIsGreedy, ParamIsOptionalOrHasDefault, ParamStart } from '../types/params';
+import { Param } from '../types/paramTypes';
+import { Identity } from '../types/utilities';
+import { MakeOptional } from '../utilities/makeOptional';
 type WithParamsParamsInput<TValue extends string> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? Record<ExtractParamName<TParam>, Param | undefined> & WithParamsParamsInput<Rest> : {};
 type WithParamsParamsOutput<TValue extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? ExtractParamName<TParam> extends keyof TParams ? TParams[ExtractParamName<TParam>] extends Param ? Record<ExtractParamName<TParam>, {
     param: TParams[ExtractParamName<TParam>];

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/{src/services → services}/zod.d.ts

@@ -1,5 +1,5 @@
-import { ParamGetSet } from '../../types/paramTypes';
-import { Routes } from '../../types/route';
+import { ParamGetSet } from '../types/paramTypes';
+import { Routes } from '../types/route';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { ZodType } from 'zod';
 export interface ZodSchemaLike extends StandardSchemaV1<any> {

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

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 '../../types/paramTypes';
-import { PrefetchConfig } from '../../types/prefetch';
-import { RouteMeta } from '../../types/register';
-import { Route } from '../../types/route';
-import { ResolvedRoute } from './resolved';
-import { ComponentProps } from '../../services/component';
-import { PropsCallbackContext } from '../../types/props';
-import { Identity, MaybePromise } from '../../types/utilities';
-import { ToMeta } from '../../types/meta';
-import { ToState } from '../../types/state';
-import { ToName } from '../../types/name';
-import { UrlPart, UrlQueryPart } from '../../services/withParams';
-import { RouteContext, ToRouteContext } from '../../types/routeContext';
-import { RouterViewProps } from '../../components/routerView';
-import { ToUrl } from '../../types/url';
-import { CombineUrl } from '../../services/combineUrl';
+import { Param } from './paramTypes';
+import { PrefetchConfig } from './prefetch';
+import { RouteMeta } from './register';
+import { Route } from './route';
+import { ResolvedRoute, WithData } from './resolved';
+import { ComponentProps } from '../services/component';
+import { PropsCallbackContext } from './props';
+import { AnyFunction, Identity, MaybePromise } from './utilities';
+import { ToMeta } from './meta';
+import { ToName } from './name';
+import { UrlPart, UrlQueryPart } from '../services/withParams';
+import { RouteContext } from './routeContext';
+import { RouterViewProps } from '../components/routerView';
+import { ToUrl } from './url';
+import { CombineUrl } from '../services/combineUrl';
+import { RouteView } from './routeViews';
 export type WithHost<THost extends string | UrlPart = string | UrlPart> = {
     /**
      * Host part of URL.
@@ -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

@@ -1,15 +1,15 @@
-import { Hooks } from '../../models/hooks';
-import { ResolvedRoute, RouterResolvedRouteUnion, ResolvedRouteUnion } from '../../types/resolved';
-import { MaybePromise } from '../../types/utilities';
-import { Route, Routes } from '../../types/route';
-import { RouterReject } from '../../types/routerReject';
-import { RouterPush } from '../../types/routerPush';
-import { RouterReplace } from '../../types/routerReplace';
-import { Rejection, Rejections } from '../../types/rejection';
-import { RouteContext, RouteContextToRejection, RouteContextToRoute } from '../../types/routeContext';
-import { RouterAbort } from '../../types/routerAbort';
-import { CallbackContextAbort, CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from '../../types/callbackContext';
-import { RouteUpdate } from '../../types/routeUpdate';
+import { Hooks } from '../models/hooks';
+import { ResolvedRoute, RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
+import { MaybePromise } from './utilities';
+import { Route, Routes } from './route';
+import { RouterReject } from './routerReject';
+import { RouterPush } from './routerPush';
+import { RouterReplace } from './routerReplace';
+import { Rejection, Rejections } from './rejection';
+import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { RouterAbort } from './routerAbort';
+import { CallbackContextAbort, CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from './callbackContext';
+import { RouteUpdate } from './routeUpdate';
 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> = {
@@ -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}/paramTypes.d.ts

@@ -1,5 +1,5 @@
-import { ValibotSchemaLike } from '../../services/valibot';
-import { ZodSchemaLike } from '../../services/zod';
+import { ValibotSchemaLike } from '../services/valibot';
+import { ZodSchemaLike } from '../services/zod';
 export type ParamExtras = {
     invalid: (message?: string) => never;
 };

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

@@ -1,4 +1,4 @@
-import { LiteralParam, Param, ParamGetSet, ParamGetter } from '../../types/paramTypes';
+import { LiteralParam, Param, ParamGetSet, ParamGetter } from './paramTypes';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 export declare const paramStart = "[";
 export type ParamStart = typeof paramStart;

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