@kitbag/router 0.24.2 → 0.25.0

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

@@ -1,7 +1,12 @@
 import { RouterAssets } from './services/createRouterAssets';
 import { RegisteredRouter } from './types/register';
-export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, PropsGetter, RouterViewPropsGetter, CreateRouteProps, ToRoute, } from './types/createRouteOptions';
-export type { RejectionHooks, HookRemove, BeforeHookLifecycle, AfterHookLifecycle, HookLifecycle, BeforeEnterHookContext, BeforeEnterHook, AddBeforeEnterHook, BeforeUpdateHookContext, BeforeUpdateHook, AddBeforeUpdateHook, BeforeLeaveHookContext, BeforeLeaveHook, AddBeforeLeaveHook, AfterEnterHookContext, AfterEnterHook, AddAfterEnterHook, AfterUpdateHookContext, AfterUpdateHook, AddAfterUpdateHook, AfterLeaveHookContext, AfterLeaveHook, AddAfterLeaveHook, RejectionHookContext, RejectionHook, AddRejectionHook, ErrorHookContext, ErrorHook, AddErrorHook, } from './types/hooks';
+export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, PropsGetter, RouterViewPropsGetter, CreateRouteProps, ToRoute } from './types/createRouteOptions';
+export type { RouteAddView, AddViewOptions, AddViewPropsGetter, AddViewPropsCallbackContext } from './types/addView';
+export type { RouteAddLoader, AddLoaderOptions, LoaderGetter } from './types/addLoader';
+export type { RouteCallbackContext } from './types/routeCallbackContext';
+export type { RouteViews } from './types/routeViews';
+export type { RouteLoader, RouteLoaders } from './types/routeLoaders';
+export type { RejectionHooks, HookRemove, BeforeHookLifecycle, AfterHookLifecycle, HookLifecycle, BeforeEnterHookContext, BeforeEnterHook, AddBeforeEnterHook, BeforeUpdateHookContext, BeforeUpdateHook, AddBeforeUpdateHook, BeforeLeaveHookContext, BeforeLeaveHook, AddBeforeLeaveHook, AfterEnterHookContext, AfterEnterHook, AddAfterEnterHook, AfterUpdateHookContext, AfterUpdateHook, AddAfterUpdateHook, AfterLeaveHookContext, AfterLeaveHook, AddAfterLeaveHook, RejectionHookContext, RejectionHook, AddRejectionHook, ErrorHookContext, ErrorHook, AddErrorHook } from './types/hooks';
 export * from './types/paramTypes';
 export * from './types/prefetch';
 export * from './types/props';
@@ -26,7 +31,10 @@ export * from './types/urlString';
 export type { Url, CreateUrlOptions, ParseUrlOptions } from './types/url';
 export * from './types/useLink';
 export { DuplicateParamsError } from './errors/duplicateParamsError';
+export { LoaderDataAccessError } from './errors/loaderDataAccessError';
+export { LoaderNameConflict } from './errors/loaderNameConflict';
 export { MetaPropertyConflict } from './errors/metaPropertyConflict';
+export { NavigationAbandonedError } from './errors/navigationAbandonedError';
 export { RouterNotInstalledError } from './errors/routerNotInstalledError';
 export { UseRouteInvalidError } from './errors/useRouteInvalidError';
 export { createRoute } from './services/createRoute';

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

@@ -1,5 +1,5 @@
-import { AfterEnterHook, AfterLeaveHook, AfterUpdateHook, BeforeEnterHook, BeforeLeaveHook, BeforeUpdateHook, ErrorHook, RejectionHook } from '../../types/hooks';
-import { RedirectHook } from '../../types/redirects';
+import { AfterEnterHook, AfterLeaveHook, AfterUpdateHook, BeforeEnterHook, BeforeLeaveHook, BeforeUpdateHook, ErrorHook, RejectionHook } from '../types/hooks';
+import { RedirectHook } from '../types/redirects';
 export declare class Hooks {
     redirects: Set<RedirectHook>;
     onBeforeRouteEnter: Set<BeforeEnterHook>;

package/dist/services/addLoader.d.ts

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

package/dist/services/addView.d.ts

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

package/dist/{src/services → services}/arrayOf.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 ArrayOfOptions = {
     separator?: string;
 };

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

@@ -1,5 +1,5 @@
-import { UrlPart } from '../../services/withParams';
-import { CombinePath } from '../../services/combinePath';
+import { UrlPart } from './withParams';
+import { CombinePath } from './combinePath';
 type CombineHash<TParent extends UrlPart, TChild extends UrlPart> = CombinePath<TParent, TChild>;
 export declare function combineHash<TParentHash extends UrlPart, TChildHash extends UrlPart>(parentHash: TParentHash, childHash: TChildHash): CombineHash<TParentHash, TChildHash>;
 export {};

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

@@ -1,5 +1,5 @@
-import { ToUrlPart, UrlPart, UrlParams } from '../../services/withParams';
-import { Identity } from '../../types/utilities';
+import { ToUrlPart, UrlPart, UrlParams } from './withParams';
+import { Identity } from '../types/utilities';
 export type CombinePath<TParent extends UrlPart, TChild extends UrlPart> = ToUrlPart<TParent> extends {
     params: infer TParentParams extends UrlParams;
 } ? ToUrlPart<TChild> extends {

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

@@ -1,5 +1,5 @@
-import { ToUrlPart, UrlPart, UrlParams } from '../../services/withParams';
-import { Identity } from '../../types/utilities';
+import { ToUrlPart, UrlPart, UrlParams } from './withParams';
+import { Identity } from '../types/utilities';
 type CombineQuery<TParent extends UrlPart, TChild extends UrlPart> = ToUrlPart<TParent> extends {
     params: infer TParentParams extends UrlParams;
 } ? ToUrlPart<TChild> extends {

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

@@ -1,3 +1,3 @@
-import { Param } from '../../types/paramTypes';
+import { Param } from '../types/paramTypes';
 export type CombineState<TParent extends Record<string, Param>, TChild extends Record<string, Param>> = TParent & TChild;
 export declare function combineState<TParentState extends Record<string, Param>, TChildState extends Record<string, Param>>(parentState: TParentState, childState: TChildState): CombineState<TParentState, TChildState>;

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

@@ -1,5 +1,5 @@
-import { CreateUrlOptions, ToUrl, Url } from '../../types/url';
-import { Identity } from '../../types/utilities';
+import { CreateUrlOptions, ToUrl, Url } from '../types/url';
+import { Identity } from '../types/utilities';
 export type CombineUrl<TParent extends Url, TChild extends Url> = TParent extends Url<infer TParentParams> ? TChild extends Url<infer TChildParams> ? Url<Identity<TParentParams & TChildParams>> : never : never;
 export declare function combineUrl<const TParent extends Url, const TChild extends Url>(parent: TParent, child: TChild): CombineUrl<TParent, TChild>;
 export declare function combineUrl<const TParent extends Url, const TChild extends CreateUrlOptions>(parent: TParent, child: TChild): CombineUrl<TParent, ToUrl<TChild>>;

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

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

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

@@ -1,8 +1,8 @@
 import { InjectionKey } from 'vue';
-import { AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterUpdateHook, AddAfterLeaveHook } from '../../types/hooks';
-import { Routes } from '../../types/route';
-import { Router, RouterRejections, RouterRoutes } from '../../types/router';
-import { Rejections } from '../../types/rejection';
+import { AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterUpdateHook, AddAfterLeaveHook } from '../types/hooks';
+import { Routes } from '../types/route';
+import { Router, RouterRejections, RouterRoutes } from '../types/router';
+import { Rejections } from '../types/rejection';
 type ComponentHooks<TRoutes extends Routes, TRejections extends Rejections> = {
     onBeforeRouteLeave: AddBeforeLeaveHook<TRoutes, TRejections>;
     onBeforeRouteUpdate: AddBeforeUpdateHook<TRoutes, TRejections>;

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

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

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

@@ -1,6 +1,6 @@
-import { Rejection, RouterRejection } from '../../types/rejection';
+import { Rejection, RouterRejection } from '../types/rejection';
 import { ComputedRef } from 'vue';
-import { ResolvedRoute } from '../../types/resolved';
+import { ResolvedRoute } from '../types/resolved';
 type RejectionUpdate = (rejection: Rejection) => void;
 type RejectionClear = () => void;
 type CurrentRejectionContext = {

package/dist/services/createCurrentRoute.d.ts

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

package/dist/services/createDataStore.d.ts

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

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

@@ -1,6 +1,6 @@
-import { CreateRouteOptions, ToRoute, WithHost, WithoutHost, WithoutParent, WithParent } from '../../types/createRouteOptions';
-import { ExternalRouteHooks } from '../../types/hooks';
-import { ExtractRouteContext } from '../../types/routeContext';
-import { RouteRedirects } from '../../types/redirects';
+import { CreateRouteOptions, ToRoute, WithHost, WithoutHost, WithoutParent, WithParent } from '../types/createRouteOptions';
+import { ExternalRouteHooks } from '../types/hooks';
+import { ExtractRouteContext } from '../types/routeContext';
+import { RouteRedirects } from '../types/redirects';
 export declare function createExternalRoute<const TOptions extends CreateRouteOptions & WithHost & WithoutParent>(options: TOptions): ToRoute<TOptions> & ExternalRouteHooks<ToRoute<TOptions>, TOptions['context']> & RouteRedirects<ToRoute<TOptions>>;
 export declare function createExternalRoute<const TOptions extends CreateRouteOptions & WithoutHost & WithParent>(options: TOptions): ToRoute<TOptions> & ExternalRouteHooks<ToRoute<TOptions>, ExtractRouteContext<TOptions>> & RouteRedirects<ToRoute<TOptions>>;

package/dist/services/createNavigationStores.d.ts

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

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

@@ -1,6 +1,6 @@
-import { ParamWithDefault } from '../../services/withDefault';
-import { ExtractParamType } from '../../types/params';
-import { Param, ParamGetSet } from '../../types/paramTypes';
+import { ParamWithDefault } from './withDefault';
+import { ExtractParamType } from '../types/params';
+import { Param, ParamGetSet } from '../types/paramTypes';
 export declare function createParam<TParam extends ParamWithDefault>(param: TParam): TParam;
 export declare function createParam<TParam extends Param>(param: TParam): ParamGetSet<ExtractParamType<TParam>>;
 export declare function createParam<TParam extends Param>(param: TParam, defaultValue: NoInfer<ExtractParamType<TParam>>): ParamWithDefault<TParam>;

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

@@ -1,7 +1,7 @@
-import { RejectionHooks } from '../../types/hooks';
-import { Rejection } from '../../types/rejection';
+import { RejectionHooks } from '../types/hooks';
+import { Rejection } from '../types/rejection';
 import { Component } from 'vue';
-import { RouteSetTitle } from '../../types/routeTitle';
+import { RouteSetTitle } from '../types/routeTitle';
 export declare function createRejection<TType extends string>(options: {
     type: TType;
     component?: Component;

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

@@ -1,6 +1,6 @@
-import { AddRejectionHook } from '../../types/hooks';
-import { Routes } from '../../types/route';
-import { Hooks } from '../../models/hooks';
+import { AddRejectionHook } from '../types/hooks';
+import { Routes } from '../types/route';
+import { Hooks } from '../models/hooks';
 type RejectionHooks<TRoutes extends Routes = Routes, TRejections extends string = string> = {
     onRejection: AddRejectionHook<TRejections, TRoutes>;
     store: Hooks;

package/dist/services/createResolvedRoute.d.ts

@@ -0,0 +1,4 @@
+import { RouterResolveOptions } from '../types/routerResolve';
+import { ResolvedRoute } from '../types/resolved';
+import { Route } from '../types/route';
+export declare function createResolvedRoute(route: Route, params?: Record<string, unknown>, options?: RouterResolveOptions): ResolvedRoute;

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

@@ -1,4 +1,4 @@
-import { QuerySource } from '../../types/querySource';
+import { QuerySource } from '../types/querySource';
 /**
  * Creates a dumb wrapper around URLSearchParams because URLSearchParams cannot be correctly be proxied to support writing params to the RouterRoute
  */

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

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

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

@@ -1,8 +1,8 @@
-import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from '../../types/hooks';
-import { Routes } from '../../types/route';
-import { Hooks } from '../../models/hooks';
-import { ExtractRejectionTypes, Rejection } from '../../types/rejection';
-import { RouteRedirect } from '../../types/redirects';
+import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from '../types/hooks';
+import { Routes } from '../types/route';
+import { Hooks } from '../models/hooks';
+import { ExtractRejectionTypes, Rejection } from '../types/rejection';
+import { RouteRedirect } from '../types/redirects';
 type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
     redirect: RouteRedirect;
     onBeforeRouteEnter: AddBeforeEnterHook<TRoutes, TRejections>;

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

@@ -1,5 +1,5 @@
-import { RouteRedirects } from '../../types/redirects';
-import { Route } from '../../types/route';
+import { RouteRedirects } from '../types/redirects';
+import { Route } from '../types/route';
 type CreateRouteRedirectsContext = {
     /**
      * The to route for the redirectFrom callback and the from route for the redirectTo callback.

package/dist/services/createRouteValueStore.d.ts

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

package/dist/services/createRouteViews.d.ts

@@ -0,0 +1,16 @@
+import { CreateRouteOptions, CreateRouteProps } from '../types/createRouteOptions';
+import { RouteViews } from '../types/routeViews';
+export declare const DEFAULT_VIEW_NAME = "default";
+/**
+ * Builds the initial views for a route, seeding components from the (deprecated) `component`/`components`
+ * options and prop getters from the props argument. Subsequent views are added via the route's `addView`.
+ *
+ * This is where the props argument's two shapes — a single getter for the unnamed view, or a record keyed
+ * by view name — are normalized, so the rest of the router only deals with views keyed by name.
+ */
+export declare function createRouteViews(options: CreateRouteOptions, props?: CreateRouteProps): RouteViews;
+/**
+ * The names of the views that have a props getter. A view without one is never computed, so waiting on it
+ * would never settle.
+ */
+export declare function viewNamesWithProps(views: RouteViews): string[];

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

@@ -1,6 +1,6 @@
-import { Routes } from '../../types/route';
-import { Router, RouterOptions } from '../../types/router';
-import { EmptyRouterPlugin, RouterPlugin } from '../../types/routerPlugin';
+import { Routes } from '../types/route';
+import { Router, RouterOptions } from '../types/router';
+import { EmptyRouterPlugin, RouterPlugin } from '../types/routerPlugin';
 /**
  * Creates a router instance for a Vue application, equipped with methods for route handling, lifecycle hooks, and state management.
  *

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

@@ -1,14 +1,14 @@
-import { Router, RouterRoutes, RouterRejections } from '../../types/router';
+import { Router, RouterRoutes, RouterRejections } from '../types/router';
 import { InjectionKey } from 'vue';
-import { createRouterView } from '../../components/routerView';
-import { createRouterLink } from '../../components/routerLink';
-import { createUseRoute } from '../../compositions/useRoute';
-import { createUseRouter } from '../../compositions/useRouter';
-import { createUseQueryValue } from '../../compositions/useQueryValue';
-import { createUseLink } from '../../compositions/useLink';
-import { createIsRoute } from '../../guards/routes';
-import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../../types/hooks';
-import { createUseRejection } from '../../compositions/useRejection';
+import { createRouterView } from '../components/routerView';
+import { createRouterLink } from '../components/routerLink';
+import { createUseRoute } from '../compositions/useRoute';
+import { createUseRouter } from '../compositions/useRouter';
+import { createUseQueryValue } from '../compositions/useQueryValue';
+import { createUseLink } from '../compositions/useLink';
+import { createIsRoute } from '../guards/routes';
+import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../types/hooks';
+import { createUseRejection } from '../compositions/useRejection';
 export type RouterAssets<TRouter extends Router> = {
     /**
      * Registers a hook that is called before a route is left. Must be called from setup.

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

@@ -1,10 +1,10 @@
-import { RouterPush } from '../../types/routerPush';
-import { RouterReject } from '../../types/routerReject';
-import { RouterReplace } from '../../types/routerReplace';
-import { Routes } from '../../types/route';
-import { Rejections } from '../../types/rejection';
-import { RouteUpdate } from '../../types/routeUpdate';
-import { ResolvedRoute } from '../../types/resolved';
+import { RouterPush } from '../types/routerPush';
+import { RouterReject } from '../types/routerReject';
+import { RouterReplace } from '../types/routerReplace';
+import { Routes } from '../types/route';
+import { Rejections } from '../types/rejection';
+import { RouteUpdate } from '../types/routeUpdate';
+import { ResolvedRoute } from '../types/resolved';
 /**
  * A function that can be called to abort a routing operation.
  */

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

@@ -1,4 +1,4 @@
-import { History, Listener } from '../../services/history';
+import { History, Listener } from './history';
 type NavigationPushOptions = {
     replace?: boolean;
     state?: unknown;

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

@@ -1,5 +1,5 @@
-import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook, RejectionHookRunner, AddRejectionHook } from '../../types/hooks';
-import { HasVueAppStore } from '../../services/createVueAppStore';
+import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook, RejectionHookRunner, AddRejectionHook } from '../types/hooks';
+import { HasVueAppStore } from './createVueAppStore';
 export declare const getRouterHooksKey: (routerKey: import('vue').InjectionKey<import('../main').Router>) => import('vue').InjectionKey<RouterHooks>;
 export type RouterHooks = HasVueAppStore & {
     runBeforeRouteHooks: BeforeHookRunner;

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

@@ -1,3 +1,3 @@
-import { Router } from '../../types/router';
+import { Router } from '../types/router';
 import { InjectionKey } from 'vue';
 export declare function createRouterKeyStore<TValue>(): (routerKey: InjectionKey<Router>) => InjectionKey<TValue>;

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

@@ -1,4 +1,4 @@
-import { CreateRouterPluginOptions, RouterPlugin, PluginRouteHooks } from '../../types/routerPlugin';
-import { Rejections } from '../../types/rejection';
-import { Routes } from '../../types/route';
+import { CreateRouterPluginOptions, RouterPlugin, PluginRouteHooks } from '../types/routerPlugin';
+import { Rejections } from '../types/rejection';
+import { Routes } from '../types/route';
 export declare function createRouterPlugin<TRoutes extends Routes = [], TRejections extends Rejections = []>(plugin: CreateRouterPluginOptions<TRoutes, TRejections>): RouterPlugin<TRoutes, TRejections> & PluginRouteHooks<TRoutes, TRejections>;

package/dist/services/createRouterRoute.d.ts

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

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

@@ -1,2 +1,2 @@
-import { CreateUrlOptions, ToUrl } from '../../types/url';
+import { CreateUrlOptions, ToUrl } from '../types/url';
 export declare function createUrl<const T extends CreateUrlOptions>(options: T): ToUrl<T>;