@kitbag/router 0.24.3 → 0.26.0

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

@@ -14,6 +14,11 @@ type UrlPartsInput = {
 };
 export declare function stringifyUrl(parts: UrlPartsInput): UrlString;
 export declare function parseUrl(value: string): UrlParts;
+/**
+ * Ignores host, and sorts query params because the router reorders them when it separates declared
+ * params from the rest.
+ */
+export declare function isSameUrl(left: string, right: string): boolean;
 export declare function updateUrl(url: string, updates: UrlPartsInput): UrlString;
 export declare function updateUrl(url: Partial<UrlParts>, updates: UrlPartsInput): UrlParts;
 export {};

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/services/zod.spec.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/types/addLoader.d.ts

@@ -0,0 +1,70 @@
+import { RouteWithMethods } from './routeWithMethods';
+import { PrefetchConfig } from './prefetch';
+import { TransformerOptions } from '../services/payload';
+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, TValue = unknown> = TransformerOptions<TValue> & {
+    /**
+     * 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, Awaited<ReturnType<TGetter>>>) => AddLoaderReturn<TUrl, TMatches, AddLoaderLoaders<CurrentMatchLoaders<TMatches>, TName, ReturnType<TGetter>>>;
+};
+export {};

package/dist/types/addView.d.ts

@@ -0,0 +1,109 @@
+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 { TransformerOptions } from '../services/payload';
+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> = TransformerOptions<PayloadValueOf<TGetter>> & {
+    /**
+     * 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;
+};
+/**
+ * What a getter resolves to, which is what its payload options carry.
+ */
+type PayloadValueOf<TGetter> = TGetter extends (...args: any[]) => any ? Awaited<ReturnType<TGetter>> : unknown;
+/**
+ * {@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> = TransformerOptions<PayloadValueOf<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}/callbackContext.d.ts

@@ -1,3 +1,4 @@
+import { RedirectStatus } from './router';
 import { RouterPush } from './routerPush';
 export type CallbackContextSuccess = {
     status: 'SUCCESS';
@@ -6,6 +7,14 @@ export type CallbackContextPush = {
     status: 'PUSH';
     to: Parameters<RouterPush>;
 };
+export type CallbackContextRedirect = {
+    status: 'REDIRECT';
+    to: Parameters<RouterPush>;
+    /**
+     * The status the redirect declared, or undefined to use the router's `redirectStatus`.
+     */
+    redirectStatus: RedirectStatus | undefined;
+};
 export type CallbackContextReject = {
     status: 'REJECT';
     type: string;

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

@@ -1,5 +1,5 @@
 import { Hooks } from '../models/hooks';
-import { ResolvedRoute, RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
+import { RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
 import { MaybePromise } from './utilities';
 import { Route, Routes } from './route';
 import { RouterReject } from './routerReject';
@@ -8,7 +8,7 @@ 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 { CallbackContextAbort, CallbackContextPush, CallbackContextRedirect, 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[];
@@ -107,10 +107,10 @@ export type BeforeUpdateHookContext<TRoutes extends Routes = Routes, TRejections
 };
 export type BeforeUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: BeforeUpdateHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddBeforeUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: BeforeUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
-export type BeforeLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = BeforeHookContext<TRouteTo, TRoutes, TRejections> & {
+export type BeforeLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = Omit<BeforeHookContext<TRouteTo, TRoutes, TRejections>, 'update'> & {
     from: ResolvedRouteUnion<TRouteFrom>;
 };
-export type BeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: BeforeLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
+export type BeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo> | null, context: BeforeLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddBeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: BeforeLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
 export type AfterEnterHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AfterHookContext<TRouteTo, TRoutes, TRejections> & {
     from: ResolvedRouteUnion<TRouteFrom> | null;
@@ -122,19 +122,19 @@ export type AfterUpdateHookContext<TRoutes extends Routes = Routes, TRejections
 };
 export type AfterUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: AfterUpdateHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddAfterUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: AfterUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
-export type AfterLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AfterHookContext<TRouteTo, TRoutes, TRejections> & {
+export type AfterLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = Omit<AfterHookContext<TRouteTo, TRoutes, TRejections>, 'update'> & {
     from: ResolvedRouteUnion<TRouteFrom>;
 };
-export type AfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: AfterLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
+export type AfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo> | null, context: AfterLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddAfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: AfterLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
-export type BeforeHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject | CallbackContextAbort;
+export type BeforeHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextRedirect | CallbackContextReject | CallbackContextAbort;
 export type AfterHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject;
 export type BeforeHookRunner = <TRoutes extends Routes>(context: {
-    to: RouterResolvedRouteUnion<TRoutes>;
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
 }) => Promise<BeforeHookResponse>;
 export type AfterHookRunner = <TRoutes extends Routes>(context: {
-    to: RouterResolvedRouteUnion<TRoutes>;
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
 }) => Promise<AfterHookResponse>;
 export type RejectionHookContext<TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = {
@@ -147,21 +147,20 @@ export type RejectionHookRunner<TRejection extends Rejection = Rejection, TRoute
     to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
 }) => void;
-export type ErrorHookContext<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
-    to: RouterResolvedRouteUnion<TRoutes>;
+export type ErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
-    source: 'props' | 'hook' | 'component';
+    source: 'props' | 'loader' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
-    update: RouteUpdate<ResolvedRoute<TRoute>>;
 };
-export type ErrorHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (error: unknown, context: ErrorHookContext<TRoute, TRoutes, TRejections>) => void;
-export type AddErrorHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: ErrorHook<TRoute, TRoutes, TRejections>) => HookRemove;
+export type ErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (error: unknown, context: ErrorHookContext<TRoutes, TRejections>) => void;
+export type AddErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: ErrorHook<TRoutes, TRejections>) => HookRemove;
 export type ErrorHookRunnerContext<TRoutes extends Routes = Routes> = {
-    to: RouterResolvedRouteUnion<TRoutes>;
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     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,4 @@
-import { ValibotSchemaLike } from '../services/valibot';
-import { ZodSchemaLike } from '../services/zod';
+import { ArkTypeSchemaLike, ValibotSchemaLike, ZodSchemaLike } from '../services/standardSchema';
 export type ParamExtras = {
     invalid: (message?: string) => never;
 };
@@ -11,4 +10,4 @@ export type ParamGetSet<T = any> = {
     defaultValue?: T;
 };
 export type LiteralParam = string | number | boolean;
-export type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | ZodSchemaLike | ValibotSchemaLike | LiteralParam;
+export type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | ZodSchemaLike | ValibotSchemaLike | ArkTypeSchemaLike | LiteralParam;

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

@@ -33,7 +33,7 @@ export type ExtractParamName<TParam extends PropertyKey> = TParam extends string
  * @template TParam - The parameter type.
  * @returns The extracted type, or 'string' as a fallback.
  */
-export type ExtractParamType<TParam extends Param> = Param extends TParam ? unknown : TParam extends ParamGetSet<infer Type> ? Type : TParam extends DateConstructor ? Date : TParam extends JSON ? unknown : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TParam> : TParam extends LiteralParam ? TParam : string;
+export type ExtractParamType<TParam extends Param> = Param extends TParam ? unknown : TParam extends ParamGetSet<infer Type> ? Type : TParam extends DateConstructor ? Date : TParam extends JSON ? unknown : TParam extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TParam> : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends LiteralParam ? TParam : string;
 export type ParamIsOptional<TParam extends string> = TParam extends `?${string}` ? true : false;
 export type ParamIsGreedy<TParam extends string> = TParam extends `${string}*` ? true : false;
 export type ParamIsOptionalOrHasDefault<TParamName extends string, TParam extends Param | undefined> = ParamIsOptional<TParamName> extends true ? true : TParam extends Required<ParamGetSet> ? true : false;

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

@@ -1,5 +1,6 @@
 import { ResolvedRouteUnion } from './resolved';
 import { Route, Routes } from './route';
+import { RedirectStatus } from './router';
 import { RouterReplace } from './routerReplace';
 import { UrlParamsReading, UrlParamsWriting } from './url';
 import { AllPropertiesAreOptional, MaybePromise } from './utilities';
@@ -18,12 +19,19 @@ type RedirectHookContext<TRoutes extends Routes> = {
 };
 export type RedirectHook<TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: RedirectHookContext<TRoutes>) => MaybePromise<void>;
 export type RouteRedirectCallback<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = (params: UrlParamsReading<TRouteFrom>) => UrlParamsWriting<TRouteTo>;
+export type RouteRedirectOptions = {
+    /**
+     * The http status a server responds with for this redirect when server rendering. Defaults to the
+     * router's `redirectStatus`.
+     */
+    status?: RedirectStatus;
+};
 /**
  * This type is purposely wide to prevent type errors in RouteRedirectFrom where the TRouteTo generic cannot be inferred.
  */
-export type RouteRedirect = (to: Route, callback?: (params: any) => any) => void;
-export type RedirectToArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [to: TRouteTo, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>] : [to: TRouteTo, params: RouteRedirectCallback<TRouteTo, TRouteFrom>];
+export type RouteRedirect = (to: Route, callback?: (params: any) => any, options?: RouteRedirectOptions) => void;
+export type RedirectToArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [to: TRouteTo, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions] : [to: TRouteTo, params: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions];
 export type RouteRedirectTo<TRouteFrom extends Route = Route> = <TRouteTo extends Route>(...args: RedirectToArgs<TRouteTo, TRouteFrom>) => void;
-export type RedirectFromArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [from: TRouteFrom, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>] : [from: TRouteFrom, params: RouteRedirectCallback<TRouteTo, TRouteFrom>];
+export type RedirectFromArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [from: TRouteFrom, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions] : [from: TRouteFrom, params: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions];
 export type RouteRedirectFrom<TRouteTo extends Route = Route> = <TRouteFrom extends Route>(...args: RedirectFromArgs<TRouteTo, TRouteFrom>) => void;
 export {};

package/dist/types/redirects.spec-d.d.ts

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

package/dist/types/register.spec.d.ts

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

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

@@ -1,10 +1,14 @@
-import { Ref } from 'vue';
+import { Component, Ref } from 'vue';
 import { Route } from './route';
 import { Router } from './router';
 import { RouterReject } from './routerReject';
 import { Hooks } from '../models/hooks';
-export declare const BUILT_IN_REJECTION_TYPES: readonly ["NotFound"];
-export type BuiltInRejectionType = (typeof BUILT_IN_REJECTION_TYPES)[number];
+import { GetTitleCallback } from './routeTitle';
+export declare const BUILT_IN_REJECTIONS: {
+    readonly NotFound: 404;
+};
+export type BuiltInRejectionType = keyof typeof BUILT_IN_REJECTIONS;
+export declare const NOT_FOUND_REJECTION_TYPE = "NotFound";
 export type RouterRejection<T extends Rejection = Rejection> = Ref<T | null>;
 export type RouterRejections<TRouter extends Router> = TRouter['reject'] extends RouterReject<infer TRejections extends Rejection[]> ? TRejections[number] : never;
 export declare const IS_REJECTION_SYMBOL: unique symbol;
@@ -18,11 +22,27 @@ export type RejectionInternal = {
  * Represents an immutable array of Rejection instances.
  */
 export type Rejections = readonly Rejection[];
-export type Rejection<TType extends string = string> = {
+export type RejectionOptions<TType extends string = string> = {
     /**
      * The type of rejection.
      */
     type: TType;
+    /**
+     * The component rendered while this rejection is in effect.
+     */
+    component?: Component;
+    /**
+     * The http status a server should respond with while this rejection is in effect. 404 for something
+     * missing, 401 or 403 for something gated, 503 for something temporary. Defaults to the router's
+     * `rejectStatus`.
+     */
+    status?: number;
+};
+export type Rejection<TType extends string = string> = Pick<RejectionOptions<TType>, 'type' | 'status'> & {
+    /**
+     * Returns the title of the rejection from its `setTitle` callback.
+     */
+    getTitle: GetTitleCallback;
 };
 export type RejectionType<TRejections extends Rejections | undefined> = unknown extends TRejections ? never : Rejections extends TRejections ? string : undefined extends TRejections ? string : TRejections extends Rejections ? TRejections[number]['type'] : never;
 export type ExtractRejections<T> = T extends {