@kitbag/router 0.24.3 → 0.26.0

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

@@ -1,6 +1,11 @@
 import { RouterAssets } from './services/createRouterAssets';
 import { RegisteredRouter } from './types/register';
 export type { WithHost, WithoutHost, WithParent, WithoutParent, CreateRouteOptions, PropsGetter, RouterViewPropsGetter, CreateRouteProps, ToRoute } from './types/createRouteOptions';
+export type { RouteAddView, AddViewOptions, AddViewPropsGetter, AddViewPropsCallbackContext } from './types/addView';
+export type { RouteAddLoader, AddLoaderOptions, LoaderGetter } from './types/addLoader';
+export type { RouteCallbackContext } from './types/routeCallbackContext';
+export type { RouteViews } from './types/routeViews';
+export type { RouteLoader, RouteLoaders } from './types/routeLoaders';
 export type { RejectionHooks, HookRemove, BeforeHookLifecycle, AfterHookLifecycle, HookLifecycle, BeforeEnterHookContext, BeforeEnterHook, AddBeforeEnterHook, BeforeUpdateHookContext, BeforeUpdateHook, AddBeforeUpdateHook, BeforeLeaveHookContext, BeforeLeaveHook, AddBeforeLeaveHook, AfterEnterHookContext, AfterEnterHook, AddAfterEnterHook, AfterUpdateHookContext, AfterUpdateHook, AddAfterUpdateHook, AfterLeaveHookContext, AfterLeaveHook, AddAfterLeaveHook, RejectionHookContext, RejectionHook, AddRejectionHook, ErrorHookContext, ErrorHook, AddErrorHook } from './types/hooks';
 export * from './types/paramTypes';
 export * from './types/prefetch';
@@ -26,9 +31,14 @@ 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 { PayloadValueError } from './errors/payloadValueError';
 export { RouterNotInstalledError } from './errors/routerNotInstalledError';
 export { UseRouteInvalidError } from './errors/useRouteInvalidError';
+export { SsrOptionRequiredError } from './errors/ssrOptionRequiredError';
 export { createRoute } from './services/createRoute';
 export { createRejection } from './services/createRejection';
 export { createExternalRoute } from './services/createExternalRoute';

package/dist/services/addLoader.d.ts

@@ -0,0 +1,43 @@
+import { AnyPayloadTransformer } from './payload';
+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;
+    transformer?: AnyPayloadTransformer;
+};
+/**
+ * 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;
+    transformer: AnyPayloadTransformer | 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, transformer }: 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,40 @@
+import { Component } from 'vue';
+import { AnyPayloadTransformer } from './payload';
+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;
+    transformer?: AnyPayloadTransformer;
+};
+/**
+ * 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;
+    transformer: AnyPayloadTransformer | 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, transformer }: View): CreatedRouteOptions;
+export {};

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

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

package/dist/services/createActivityTracker.d.ts

@@ -0,0 +1,6 @@
+export type ActivityTracker = {
+    add: (...work: Promise<unknown>[]) => void;
+    wrap: <TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>) => (...args: TArgs) => Promise<TResult>;
+    idle: () => Promise<void>;
+};
+export declare function createActivityTracker(): ActivityTracker;

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

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

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

@@ -1,11 +1,8 @@
 import { Rejection, RouterRejection } from '../types/rejection';
-import { ComputedRef } from 'vue';
-import { ResolvedRoute } from '../types/resolved';
 type RejectionUpdate = (rejection: Rejection) => void;
 type RejectionClear = () => void;
 type CurrentRejectionContext = {
     currentRejection: RouterRejection;
-    currentRejectionRoute: ComputedRef<ResolvedRoute | null>;
     updateRejection: RejectionUpdate;
     clearRejection: RejectionClear;
 };

package/dist/services/createCurrentRoute.d.ts

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

package/dist/services/createDataStore.d.ts

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

package/dist/services/createNavigationIds.d.ts

@@ -0,0 +1,6 @@
+export type NavigationIds = {
+    getNavigationId: () => string;
+    isCurrentNavigationId: (id: string) => boolean;
+    stopNavigationIds: () => void;
+};
+export declare function createNavigationIds(): NavigationIds;

package/dist/services/createNavigationStores.d.ts

@@ -0,0 +1,36 @@
+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 store built ahead of
+ * a navigation is staged for it to pick up — staged rather than handed over directly because it is built
+ * before that navigation starts.
+ */
+export type NavigationStores = {
+    /**
+     * The store the rendered route reads props from.
+     */
+    current: () => DataStore;
+    /**
+     * Parks a store for the next navigation. A store already parked is disposed, since staging a second
+     * store before a navigation arrives abandons the first.
+     */
+    stage: (store: DataStore) => void;
+    /**
+     * The staged store, created when nothing was staged, so a navigation can compute into it ahead of
+     * adopting it.
+     */
+    staged: () => DataStore;
+    /**
+     * 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/services/createRejection.d.ts

@@ -0,0 +1,4 @@
+import { RejectionHooks } from '../types/hooks';
+import { Rejection, RejectionOptions } from '../types/rejection';
+import { RouteSetTitle } from '../types/routeTitle';
+export declare function createRejection<TType extends string>(options: RejectionOptions<TType>): Rejection<TType> & RejectionHooks<TType> & RouteSetTitle;

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

@@ -11,7 +11,7 @@ type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[]
     onAfterRouteEnter: AddAfterEnterHook<TRoutes, TRejections>;
     onAfterRouteUpdate: AddAfterUpdateHook<TRoutes, TRejections>;
     onAfterRouteLeave: AddAfterLeaveHook<TRoutes, TRejections>;
-    onError: AddErrorHook<TRoutes[number], TRoutes, TRejections>;
+    onError: AddErrorHook<TRoutes, TRejections>;
     onRejection: AddRejectionHook<ExtractRejectionTypes<TRejections>, TRoutes>;
     store: Hooks;
 };

package/dist/services/createRouteValueStore.d.ts

@@ -0,0 +1,88 @@
+import { ResolvedRoute, WithData } from '../types/resolved';
+import { HasVueAppStore } from './createVueAppStore';
+import { CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from '../types/callbackContext';
+import { DataKind } from './createNavigationStores';
+import { PropsResult } from '../utilities/props';
+import { MaybePromise } from '../types/utilities';
+import { ComputationFilter } from './getComputations';
+/**
+ * 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 store of a route's values, whichever store that is.
+ */
+export type ValueStore = {
+    /**
+     * Computes the route's values, or only those the filter keeps, and reports how they settle.
+     */
+    compute: (route: ResolvedRoute, filter?: ComputationFilter) => RouteValueResponses;
+    /**
+     * Adopts values that already settled, in place of running their getters.
+     */
+    fill: (route: ResolvedRoute, values: RouteValue[]) => void;
+};
+/**
+ * A store kept apart from the navigation until it is staged, so values can be computed ahead of a
+ * navigation that may never come.
+ */
+export type DetachedStore = ValueStore & {
+    /**
+     * Becomes the staged store, replacing whatever was staged, and starts over empty.
+     */
+    stage: () => void;
+    /**
+     * Abandons what was computed and starts over.
+     */
+    reset: () => void;
+    /**
+     * Abandons what was computed.
+     */
+    dispose: () => void;
+};
+/**
+ * A value the store holds for a route: which computation it belongs to, and what it resolved to.
+ */
+export type RouteValue = {
+    kind: DataKind;
+    depth: number;
+    name: string;
+    value: unknown;
+};
+export type RouteValueStore = HasVueAppStore & {
+    createDetachedStore: () => DetachedStore;
+    /**
+     * The store the next navigation adopts, created when nothing is staged. Values computed into it ahead of
+     * the navigation are found under way when the navigation commits, while the rendered route keeps reading
+     * its own store meanwhile.
+     */
+    staged: () => ValueStore;
+    /**
+     * Makes the staged store current and computes whatever the route still lacks.
+     */
+    commit: (route: ResolvedRoute) => RouteValueResponses;
+    /**
+     * The values currently settled in the store.
+     */
+    getValues: (route: ResolvedRoute) => RouteValue[];
+    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}/createRouterCallbackContext.d.ts

@@ -17,6 +17,6 @@ type RouterCallbackContext<TRoutes extends Routes = Routes, TRejections extends
     abort: CallbackContextAbort;
 };
 export declare function createRouterCallbackContext<TRoutes extends Routes, TRejections extends Rejections>({ to }: {
-    to: ResolvedRoute;
+    to: ResolvedRoute | null;
 }): RouterCallbackContext<TRoutes, TRejections>;
 export {};

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

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

package/dist/services/createServerRedirect.d.ts

@@ -0,0 +1,14 @@
+import { RedirectStatus, RenderRedirect } from '../types/router';
+type ServerRedirect = {
+    /**
+     * Captures a redirect as the render's response. A server responds per redirect hop, so only the first
+     * is kept: the browser follows it, and the next request takes it from there.
+     */
+    setServerRedirect: (status: RedirectStatus, location: string) => void;
+    /**
+     * The redirect the render captured, or undefined when it has not redirected.
+     */
+    getServerRedirect: () => RenderRedirect | undefined;
+};
+export declare function createServerRedirect(): ServerRedirect;
+export {};

package/dist/services/getComputations.d.ts

@@ -0,0 +1,40 @@
+import { PrefetchConfig } from '../types/prefetch';
+import { ResolvedRoute } from '../types/resolved';
+import { CreatedRouteOptions } from '../types/route';
+import { DataKind } from './createNavigationStores';
+import { AnyPayloadTransformer } from './payload';
+import { AnyFunction } from '../types/utilities';
+/**
+ * Something a route computes: a view's props getter, or a loader. Both are a named callback belonging to
+ * one match, so both are stored the same way — what differs is only what waits on them.
+ */
+export type Computation = {
+    kind: DataKind;
+    id: string;
+    name: string;
+    depth: number;
+    key: string;
+    run: AnyFunction;
+    routePrefetch: PrefetchConfig | undefined;
+    prefetch: PrefetchConfig | undefined;
+    transformer: AnyPayloadTransformer | undefined;
+};
+/**
+ * Where a value lives, which is all that is needed to read it back out of a store.
+ */
+export type ValueLocation = {
+    kind: DataKind;
+    id: string;
+    name: string;
+};
+/**
+ * Decides which of a route's computations to compute.
+ */
+export type ComputationFilter = (computation: Computation) => boolean;
+export declare function getComputations(route: ResolvedRoute): Computation[];
+/**
+ * Only views with a getter, since a view with none is never computed and waiting on it would never settle.
+ */
+export declare function propsLocations(match: CreatedRouteOptions): ValueLocation[];
+export declare function loaderLocations(match: CreatedRouteOptions): ValueLocation[];
+export declare function isKind(kind: DataKind): (computation: Computation) => boolean;

package/dist/services/getGlobalRouteHooks.d.ts

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

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

@@ -1,4 +1,4 @@
 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;
+export declare function getBeforeHooksFromRoutes(to: ResolvedRoute | null, from: ResolvedRoute | null): Hooks;
+export declare function getAfterHooksFromRoutes(to: ResolvedRoute | null, from: ResolvedRoute | null): Hooks;

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

@@ -11,7 +11,6 @@ import { RouterOptions } from '../types/router';
 export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?: RouterPlugin[], options?: RouterOptions): {
     routes: (import('../main').Url & {
         id: string;
-        matched: import('../types/route').CreatedRouteOptions;
         matches: import('../types/route').CreatedRouteOptions[];
         name: string;
         meta: Record<string, unknown>;
@@ -19,7 +18,9 @@ export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?:
         prefetch?: import('../main').PrefetchConfig;
         context: import('../types/routeContext').RouteContext[];
     } & RouteInternal)[];
-    rejections: (Rejection & RejectionInternal)[];
+    rejections: (Pick<import('../types/rejection').RejectionOptions<string>, "type" | "status"> & {
+        getTitle: import('../types/routeTitle').GetTitleCallback;
+    } & RejectionInternal)[];
     getRouteByName: (type: string) => Route | undefined;
     getRejectionByType: {
         (type: BuiltInRejectionType): (Rejection & RejectionInternal);

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

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

package/dist/services/payload.d.ts

@@ -0,0 +1,86 @@
+import { DataKind } from './createNavigationStores';
+import { RouteValue } from './createRouteValueStore';
+import { PayloadValueError } from '../errors/payloadValueError';
+import { ResolvedRoute } from '../types/resolved';
+export declare const PAYLOAD_ELEMENT_ID = "kitbag-payload";
+/**
+ * The payload as a script tag to embed in the document a server sends.
+ *
+ * `<` is escaped so nothing in the payload can close the tag early, and the two unicode line separators
+ * because they terminate a line in javascript source. All three are json unicode escapes, so `JSON.parse`
+ * gives back exactly what went in.
+ */
+export declare function payloadToScript(payload: RouterPayload): string;
+export type TransformerOptions<TValue = unknown> = {
+    /**
+     * Transforms a value across the server render payload: `stringify` writes the value into the payload
+     * on the server, and `parse` reads it back on the client during hydration. Declare one for any value
+     * json cannot carry faithfully, such as a `Map`, `Set`, or `Date`, so the client adopts the same
+     * value the server rendered with. Defaults to json.
+     */
+    transformer?: PayloadTransformer<TValue>;
+};
+export type PayloadTransformer<TValue = unknown> = {
+    /**
+     * Turns a value into a string for the payload.
+     */
+    stringify: (value: TValue) => string;
+    /**
+     * Turns a string from the payload back into a value.
+     */
+    parse: (encoded: string) => TValue;
+};
+/**
+ * A transformer whose value type has been erased. Every loader's and view's transformer is stored in
+ * one record, so a stored one is typed for some value the record no longer names — `unknown` would
+ * claim it accepts anything, which a typed stringify does not.
+ */
+export type AnyPayloadTransformer = PayloadTransformer<any>;
+export declare const jsonTransformer: PayloadTransformer;
+export type PayloadValue = {
+    kind: DataKind;
+    depth: number;
+    name: string;
+    encoded: string;
+};
+export type RouterPayload = SuccessPayload | RejectPayload;
+type SuccessPayload = {
+    kind: 'success';
+    /**
+     * The url the server rendered.
+     */
+    url: string;
+    values: PayloadValue[];
+};
+type RejectPayload = {
+    kind: 'reject';
+    /**
+     * The url the server rendered.
+     */
+    url: string;
+    /**
+     * The type of the rejection the server rendered.
+     */
+    rejection: string;
+};
+export declare function isRouterPayload(value: unknown): value is RouterPayload;
+/**
+ * The payload a server embedded in the document, or undefined when this is not a hydration.
+ */
+export declare function getHydratingPayload(): RouterPayload | undefined;
+type EncodedPayloadValues = {
+    values: PayloadValue[];
+    failures: PayloadValueError[];
+};
+/**
+ * Encodes settled values for the payload, each through its own stringifier or the fallback. A value that
+ * cannot be encoded is warned about, reported as a failure, and left out, so the client computes it again.
+ */
+export declare function encodePayloadValues(route: ResolvedRoute, values: RouteValue[], fallback?: PayloadTransformer): EncodedPayloadValues;
+/**
+ * Decodes payload values for the store to adopt, each through its own stringifier or the fallback. A
+ * value that is missing from the payload or that cannot be read is warned about and left out, so its
+ * getter runs again.
+ */
+export declare function decodePayloadValues(route: ResolvedRoute, values: PayloadValue[], fallback?: PayloadTransformer): RouteValue[];
+export {};

package/dist/services/standardSchema.d.ts

@@ -0,0 +1,21 @@
+import { ParamGetSet } from '../types/paramTypes';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+export interface ZodSchemaLike extends StandardSchemaV1<any> {
+    parse: (input: any) => any;
+    def: {
+        type: string;
+    };
+}
+export interface ValibotSchemaLike extends StandardSchemaV1<any> {
+    type: string;
+}
+export interface ArkTypeSchemaLike extends StandardSchemaV1<any> {
+    extends: (def: string) => boolean;
+    branches: readonly ArkTypeSchemaLike[];
+}
+export type StandardSchemaLike = ZodSchemaLike | ValibotSchemaLike | ArkTypeSchemaLike;
+export declare function isZodSchema(value: unknown): value is ZodSchemaLike;
+export declare function isValibotSchema(value: unknown): value is ValibotSchemaLike;
+export declare function isArkTypeSchema(value: unknown): value is ArkTypeSchemaLike;
+export declare function isStandardSchema(value: unknown): value is StandardSchemaLike;
+export declare function createStandardSchemaParam<T>(schema: StandardSchemaLike): ParamGetSet<T>;