@kitbag/router 0.20.10 → 0.20.12

package/dist/services/routeRegex.d.ts

@@ -1,6 +1,7 @@
 import { Route } from '../types/route';
 import { WithParams } from './withParams';
 export declare function splitByMatches(string: string, regexp: RegExp): string[];
+export declare function generateRouteHostRegexPattern(route: Route): RegExp;
 export declare function generateRoutePathRegexPattern(route: Route): RegExp;
 export declare function generateRouteQueryRegexPatterns(route: Route): RegExp[];
 export declare function replaceParamSyntaxWithCatchAlls(value: string): string;

package/dist/services/zod.d.ts

@@ -1,11 +1,11 @@
 import { ParamGetSet } from '../types/paramTypes';
 import { Routes } from '../types/route';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { ZodSchema } from 'zod';
+import { ZodType } from 'zod';
 export interface ZodSchemaLike extends StandardSchemaV1<any> {
     parse: (input: any) => any;
 }
 export declare function zotParamsDetected(routes: Routes): boolean;
 export declare function initZod(): Promise<void>;
-export declare function isZodParam(value: unknown): value is ZodSchema;
-export declare function createZodParam<T>(schema: ZodSchema<T>): ParamGetSet<T>;
+export declare function isZodParam(value: unknown): value is ZodType;
+export declare function createZodParam<T>(schema: ZodType<T>): ParamGetSet<T>;

package/dist/types/createRouteOptions.d.ts

@@ -12,12 +12,13 @@ import { ResolvedRoute } from './resolved';
 import { ComponentProps } from '../services/component';
 import { PropsCallbackContext } from './props';
 import { MaybePromise } from './utilities';
-import { RouterView } from '../main';
 import { ToMeta } from './meta';
 import { ToState } from './state';
 import { ToName } from './name';
 import { WithHooks } from './hooks';
 import { ToWithParams, WithParams } from '../services/withParams';
+import { RouteContext, ToRouteContext } from './routeContext';
+import { RouterViewProps } from '../components/routerView';
 export type WithHost<THost extends string | WithParams = string | WithParams> = {
     /**
      * Host part of URL.
@@ -89,6 +90,10 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      * An object of named components to render using named views
      */
     components?: Record<string, Component>;
+    /**
+     * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
+     */
+    context?: RouteContext[];
     /**
      * Props have been moved to the second argument of `createRoute`. This property can no longer be used.
      *
@@ -96,14 +101,15 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      */
     props?: never;
 };
-export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions['parent']>) => MaybePromise<ComponentProps<TComponent>>;
+export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions>) => MaybePromise<ComponentProps<TComponent>>;
+export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
 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']> : PropsGetter<TOptions, typeof RouterView>;
+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 extends CreateRouteProps<TOptions> | undefined> = Omit<TOptions, 'props' | 'meta'> & {
     id: string;
     props: TProps;
@@ -117,8 +123,11 @@ type ToMatches<TOptions extends CreateRouteOptions, TProps extends CreateRoutePr
 } ? [...TParent['matches'], ToMatch<TOptions, TProps>] : [ToMatch<TOptions, TProps>];
 export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = CreateRouteOptions extends TOptions ? Route : TOptions extends {
     parent: infer TParent extends Route;
-} ? Route<ToName<TOptions['name']>, ToWithParams<TParent['host']>, CombinePath<ToWithParams<TParent['path']>, ToWithParams<TOptions['path']>>, CombineQuery<ToWithParams<TParent['query']>, ToWithParams<TOptions['query']>>, CombineHash<ToWithParams<TParent['hash']>, ToWithParams<TOptions['hash']>>, CombineMeta<ToMeta<TParent['meta']>, ToMeta<TOptions['meta']>>, CombineState<ToState<TParent['state']>, ToState<TOptions['state']>>, ToMatches<TOptions, TProps>> : Route<ToName<TOptions['name']>, TOptions extends {
+} ? Route<ToName<TOptions['name']>, ToWithParams<TParent['host']>, CombinePath<ToWithParams<TParent['path']>, ToWithParams<TOptions['path']>>, CombineQuery<ToWithParams<TParent['query']>, ToWithParams<TOptions['query']>>, CombineHash<ToWithParams<TParent['hash']>, ToWithParams<TOptions['hash']>>, CombineMeta<ToMeta<TParent['meta']>, ToMeta<TOptions['meta']>>, CombineState<ToState<TParent['state']>, ToState<TOptions['state']>>, ToMatches<TOptions, TProps>, [
+    ...ToRouteContext<TParent['context']>,
+    ...ToRouteContext<TOptions['context']>
+]> : Route<ToName<TOptions['name']>, TOptions extends {
     host: string | WithParams;
-} ? ToWithParams<TOptions['host']> : WithParams<'', {}>, ToWithParams<TOptions['path']>, ToWithParams<TOptions['query']>, ToWithParams<TOptions['hash']>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, TProps>>;
+} ? ToWithParams<TOptions['host']> : WithParams<'', {}>, ToWithParams<TOptions['path']>, ToWithParams<TOptions['query']>, ToWithParams<TOptions['hash']>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, TProps>, ToRouteContext<TOptions['context']>>;
 export declare function combineRoutes(parent: Route, child: Route): Route;
 export {};

package/dist/types/hooks.d.ts

@@ -1,9 +1,13 @@
 import { RouterRouteHooks } from '../models/RouterRouteHooks';
 import { CallbackAbortResponse, CallbackContext, CallbackContextAbort, CallbackPushResponse, CallbackRejectResponse, CallbackSuccessResponse } from '../services/createCallbackContext';
-import { ResolvedRoute } from './resolved';
+import { ResolvedRoute, RouterResolvedRouteUnion } from './resolved';
 import { MaybeArray, MaybePromise } from './utilities';
 import { Routes } from './route';
-import { RouterAfterRouteHook, RouterBeforeRouteHook } from './router';
+import { RouterReject } from './routerReject';
+import { RouterPush } from './routerPush';
+import { RouterReplace } from './routerReplace';
+import { Rejection } from './rejection';
+import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
 /**
  * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
  */
@@ -33,6 +37,38 @@ export type WithHooks = {
      */
     onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
 };
+export type InternalRouteHooks<TContext extends RouteContext[] | undefined = undefined> = {
+    /**
+     * Registers a route hook to be called before the route is entered.
+     */
+    onBeforeRouteEnter: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    /**
+     * Registers a route hook to be called before the route is left.
+     */
+    onBeforeRouteLeave: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    /**
+     * Registers a route hook to be called before the route is updated.
+     */
+    onBeforeRouteUpdate: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    /**
+     * Registers a route hook to be called after the route is entered.
+     */
+    onAfterRouteEnter: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    /**
+     * Registers a route hook to be called after the route is left.
+     */
+    onAfterRouteLeave: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+    /**
+     * Registers a route hook to be called after the route is updated.
+     */
+    onAfterRouteUpdate: AddRouterAfterRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+};
+export type ExternalRouteHooks<TContext extends RouteContext[] | undefined = undefined> = {
+    /**
+     * Registers a route hook to be called before the route is entered.
+     */
+    onBeforeRouteEnter: AddRouterBeforeRouteHook<RouteContextToRoute<TContext>, RouteContextToRejection<TContext>>;
+};
 export type BeforeHookContext = {
     to: ResolvedRoute;
     from: ResolvedRoute | null;
@@ -44,19 +80,19 @@ export type AfterHookContext = {
 };
 export type RouteHookAfterRunner = (context: AfterHookContext) => Promise<AfterRouteHookResponse>;
 export type RouteHookTiming = 'global' | 'component';
-type BeforeRouteHookRegistration<TRoutes extends Routes, TRejections extends PropertyKey> = {
+type BeforeRouteHookRegistration<TRoutes extends Routes, TRejections extends Rejection[]> = {
     lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
     hook: RouterBeforeRouteHook<TRoutes, TRejections>;
     depth: number;
 };
-export type AddComponentBeforeRouteHook<TRoutes extends Routes, TRejections extends PropertyKey> = (hook: BeforeRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
-type AfterRouteHookRegistration<TRoutes extends Routes, TRejections extends PropertyKey> = {
+export type AddComponentBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: BeforeRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
+type AfterRouteHookRegistration<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
     lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
     hook: RouterAfterRouteHook<TRoutes, TRejections>;
     depth: number;
 };
-export type AddComponentAfterRouteHook<TRoutes extends Routes, TRejections extends PropertyKey> = (hook: AfterRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
-export type AddGlobalRouteHooks<TRoutes extends Routes, TRejections extends PropertyKey> = (hooks: RouterRouteHooks<TRoutes, TRejections>) => void;
+export type AddComponentAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: AfterRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
+export type AddGlobalRouteHooks = (hooks: RouterRouteHooks) => void;
 /**
  * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
  */
@@ -126,4 +162,40 @@ export type AfterRouteHookResponse = CallbackSuccessResponse | CallbackPushRespo
  * @template TRoutes - The type of the routes configuration.
  */
 export type RouteHookResponse = BeforeRouteHookResponse | AfterRouteHookResponse;
+type RouterHookContext<TRoutes extends Routes, TRejections extends Rejection[]> = {
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+    reject: RouterReject<TRejections>;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+};
+type RouterBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Rejection[]> = RouterHookContext<TRoutes, TRejections> & {
+    abort: CallbackContextAbort;
+};
+export type HookContext<TRoutes extends Routes = Routes> = {
+    to: RouterResolvedRouteUnion<TRoutes>;
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+};
+export type RouterBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+export type AddRouterBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: RouterBeforeRouteHook<TRoutes, TRejections>) => RouteHookRemove;
+type RouterAfterRouteHookContext<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = RouterHookContext<TRoutes, TRejections>;
+export type RouterAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+export type AddRouterAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: RouterAfterRouteHook<TRoutes, TRejections>) => RouteHookRemove;
+export type RouterRouteHookBeforeRunner = (context: HookContext) => Promise<BeforeRouteHookResponse>;
+export type RouterRouteHookAfterRunner = (context: HookContext) => Promise<AfterRouteHookResponse>;
+export type RouterErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+    to: RouterResolvedRouteUnion<TRoutes>;
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+    source: 'props' | 'hook' | 'component';
+    reject: RouterReject<TRejections>;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+};
+export type RouterErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (error: unknown, context: RouterErrorHookContext<TRoutes, TRejections>) => void;
+export type AddRouterErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: RouterErrorHook<TRoutes, TRejections>) => RouteHookRemove;
+export type RouterRouteHookErrorRunnerContext<TRoutes extends Routes = Routes> = {
+    to: RouterResolvedRouteUnion<TRoutes>;
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+    source: 'props' | 'hook';
+};
+export type RouterRouteHookErrorRunner = (error: unknown, context: RouterRouteHookErrorRunnerContext) => void;
 export {};

package/dist/types/props.d.ts

@@ -1,15 +1,21 @@
-import { CallbackContext } from '../services/createCallbackContext';
-import { PropsGetter } from './createRouteOptions';
+import { CreateRouteOptions, PropsGetter } from './createRouteOptions';
 import { Route } from './route';
+import { RouterReject } from './routerReject';
+import { RouterPush } from './routerPush';
+import { RouterReplace } from './routerReplace';
+import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
 /**
  * Context provided to props callback functions
  */
-export type PropsCallbackContext<TParent extends Route | undefined = Route | undefined> = {
-    push: CallbackContext['push'];
-    replace: CallbackContext['replace'];
-    reject: CallbackContext['reject'];
-    parent: PropsCallbackParent<TParent>;
+export type PropsCallbackContext<TOptions extends CreateRouteOptions = CreateRouteOptions> = {
+    reject: RouterReject<RouteContextToRejection<ExtractRouteContext<TOptions>>>;
+    push: RouterPush<RouteContextToRoute<ExtractRouteContext<TOptions>>>;
+    replace: RouterReplace<RouteContextToRoute<ExtractRouteContext<TOptions>>>;
+    parent: PropsCallbackParent<TOptions['parent']>;
 };
+type ExtractRouteContext<TOptions extends CreateRouteOptions> = TOptions extends {
+    context: infer TContext extends RouteContext[];
+} ? TContext : [];
 export type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
     name: string;
     props: unknown;

package/dist/types/register.d.ts

@@ -4,6 +4,7 @@ import { Router, RouterOptions } from './router';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
 import { RoutesName } from './routesMap';
+import { RejectionType } from './rejection';
 /**
  * Represents the state of currently registered router, and route meta. Used to provide correct type context for
  * components like `RouterLink`, as well as for composables like `useRouter`, `useRoute`, and hooks.
@@ -39,7 +40,7 @@ export type RegisteredRoutes<T = Register> = T extends {
  */
 export type RegisteredRejectionType<T = Register> = T extends {
     router: Router<any, infer TOptions extends RouterOptions>;
-} ? keyof TOptions['rejections'] | BuiltInRejectionType : BuiltInRejectionType;
+} ? RejectionType<TOptions['rejections']> | BuiltInRejectionType : BuiltInRejectionType;
 /**
  * Represents additional metadata associated with a route, customizable via declaration merging.
  */

package/dist/types/rejection.d.ts

@@ -0,0 +1,15 @@
+import { Component } from 'vue';
+export type Rejection<TType extends string = string> = {
+    /**
+     * The type of rejection.
+     */
+    type: TType;
+    /**
+     * The component to render when the rejection occurs.
+     */
+    component: Component;
+};
+export type RejectionType<TRejections extends Rejection[] | undefined> = unknown extends TRejections ? never : Rejection[] extends TRejections ? string : undefined extends TRejections ? string : TRejections extends Rejection[] ? TRejections[number]['type'] : never;
+export type ExtractRejections<T> = T extends {
+    rejections: infer TRejections extends Rejection[];
+} ? TRejections : [];

package/dist/types/resolved.d.ts

@@ -1,5 +1,6 @@
+import { RouterRouteHooks } from '../models/RouterRouteHooks';
 import { ExtractRouteParamTypesReading } from './params';
-import { Route } from './route';
+import { Route, Routes } from './route';
 import { ExtractRouteStateParamsAsOptional } from './state';
 import { Url } from './url';
 /**
@@ -44,4 +45,16 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      * String value of the resolved URL.
      */
     href: Url;
+    /**
+     * The stores for routes including ancestors.
+     * Order of routes will be from greatest ancestor to narrowest matched.
+     * @internal
+     */
+    hooks: RouterRouteHooks[];
 }>;
+/**
+ * This type is the same as `ResolvedRoute<TRoutes[number]>` while remaining distributive
+ */
+export type RouterResolvedRouteUnion<TRoutes extends Routes> = {
+    [K in keyof TRoutes]: ResolvedRoute<TRoutes[K]>;
+}[number];

package/dist/types/route.d.ts

@@ -1,10 +1,12 @@
+import { WithParams } from '../services/withParams';
 import { Param } from './paramTypes';
 import { PrefetchConfig } from './prefetch';
 import { RouteMeta } from './register';
 import { LastInArray } from './utilities';
 import { CreateRouteOptions } from './createRouteOptions';
 import { WithHooks } from './hooks';
-import { WithParams } from '../services/withParams';
+import { RouteContext } from './routeContext';
+import { RouterRouteHooks } from '../models/RouterRouteHooks';
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
  */
@@ -22,7 +24,7 @@ export type CreatedRouteOptions = Omit<CreateRouteOptions, 'props'> & WithHooks
  * @template TPath - The type or structure of the route's path.
  * @template TQuery - The type or structure of the query parameters associated with the route.
  */
-export type Route<TName extends string = string, THost extends WithParams = WithParams, TPath extends WithParams = WithParams, TQuery extends WithParams = WithParams, THash extends WithParams = WithParams, TMeta extends RouteMeta = RouteMeta, TState extends Record<string, Param> = Record<string, Param>, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = {
+export type Route<TName extends string = string, THost extends WithParams = WithParams, TPath extends WithParams = WithParams, TQuery extends WithParams = WithParams, THash extends WithParams = WithParams, TMeta extends RouteMeta = RouteMeta, TState extends Record<string, Param> = Record<string, Param>, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[], TContext extends RouteContext[] = RouteContext[]> = {
     /**
      * Unique identifier for the route, generated by router.
     */
@@ -68,9 +70,33 @@ export type Route<TName extends string = string, THost extends WithParams = With
      * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
     */
     prefetch?: PrefetchConfig;
+    /**
+     * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
+     */
+    context: TContext;
+    /**
+     * The stores for routes including ancestors.
+     * Order of routes will be from greatest ancestor to narrowest matched.
+     * @internal
+     */
+    hooks: RouterRouteHooks[];
     /**
     * A value that represents how many parents a route has. Used for route matching
     * @internal
     */
     depth: number;
 };
+export type GenericRoute = {
+    id: string;
+    name: string;
+    host: WithParams;
+    matched: CreatedRouteOptions;
+    matches: CreatedRouteOptions[];
+    path: WithParams;
+    query: WithParams;
+    hash: WithParams;
+    meta: RouteMeta;
+    state: Record<string, Param>;
+    prefetch?: PrefetchConfig;
+    depth: number;
+};

package/dist/types/routeContext.d.ts

@@ -0,0 +1,9 @@
+import { Rejection } from './rejection';
+import { GenericRoute, Route } from './route';
+export type RouteContext = GenericRoute | Rejection;
+export type ToRouteContext<TContext extends RouteContext[] | undefined> = TContext extends RouteContext[] ? TContext : [];
+export type RouteContextToRoute<TContext extends RouteContext[] | undefined> = RouteContext[] extends TContext ? Route[] : undefined extends TContext ? Route[] : FilterRouteContextRoutes<TContext>;
+type FilterRouteContextRoutes<TContext extends RouteContext[] | undefined> = TContext extends [infer First, ...infer Rest extends RouteContext[]] ? First extends GenericRoute ? [First, ...FilterRouteContextRoutes<Rest>] : FilterRouteContextRoutes<Rest> : [];
+export type RouteContextToRejection<TContext extends RouteContext[] | undefined> = RouteContext[] extends TContext ? Rejection[] : undefined extends TContext ? Rejection[] : FilterRouteContextRejections<TContext>;
+type FilterRouteContextRejections<TContext extends RouteContext[] | undefined> = TContext extends [infer First, ...infer Rest extends RouteContext[]] ? First extends Rejection ? [First, ...FilterRouteContextRejections<Rest>] : FilterRouteContextRejections<Rest> : [];
+export {};

package/dist/types/router.d.ts

@@ -1,7 +1,7 @@
-import { App, Component, InjectionKey, Ref } from 'vue';
+import { App, InjectionKey, Ref } from 'vue';
 import { RouterHistoryMode } from '../services/createRouterHistory';
 import { RouterRoute } from './routerRoute';
-import { RouteHookRemove, WithHooks } from './hooks';
+import { AddRouterAfterRouteHook, AddRouterBeforeRouteHook, AddRouterErrorHook, WithHooks } from './hooks';
 import { PrefetchConfig } from './prefetch';
 import { ResolvedRoute } from './resolved';
 import { Route, Routes } from './route';
@@ -10,10 +10,9 @@ import { RouterReplace } from './routerReplace';
 import { RouterResolve, RouterResolveOptions } from './routerResolve';
 import { RouterReject } from './routerReject';
 import { RouterPlugin } from './routerPlugin';
-import { KeysOfUnion, MaybePromise } from './utilities';
 import { RoutesName } from './routesMap';
-import { AfterRouteHookResponse, BeforeRouteHookResponse } from '../main';
-import { CallbackContextAbort } from '../services/createCallbackContext';
+import { ToRouteContext } from './routeContext';
+import { ExtractRejections, Rejection } from './rejection';
 /**
  * Options to initialize a {@link Router} instance.
  */
@@ -42,7 +41,7 @@ export type RouterOptions = WithHooks & {
     /**
      * Components assigned to each type of rejection your router supports.
      */
-    rejections?: Partial<Record<string, Component>>;
+    rejections?: Rejection[];
     /**
      * When false, createRouterAssets must be used for component and hooks. Assets exported by the library
      * will not work with the created router instance.
@@ -80,7 +79,7 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
     /**
      * Handles route rejection based on a specified rejection type.
      */
-    reject: RouterReject<keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    reject: RouterReject<[...ExtractRejections<TOptions>, ...ExtractRejections<TPlugin>]>;
     /**
      * Forces the router to re-evaluate the current route.
      */
@@ -100,32 +99,32 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
     /**
      * Registers a hook to be called before a route is entered.
      */
-    onBeforeRouteEnter: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    onBeforeRouteEnter: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called before a route is left.
      */
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called before a route is updated.
      */
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is entered.
      */
-    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is left.
      */
-    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is updated.
      */
-    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called when an error occurs.
      * If the hook returns true, the error is considered handled and the other hooks are not run. If all hooks return false the error is rethrown
      */
-    onError: AddRouterErrorHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    onError: AddRouterErrorHook<TRoutes | TPlugin['routes'], ToRouteContext<TOptions['rejections']> | ToRouteContext<TPlugin['rejections']>>;
     /**
     * Given a URL, returns true if host does not match host stored on router instance
     */
@@ -153,55 +152,12 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      */
     key: InjectionKey<Router<TRoutes, TOptions, TPlugin>>;
 };
-type RouterHookContext<TRoutes extends Routes, TRejections extends PropertyKey> = {
-    from: RouterResolvedRouteUnion<TRoutes> | null;
-    reject: RouterReject<TRejections>;
-    push: RouterPush<TRoutes>;
-    replace: RouterReplace<TRoutes>;
-};
-type RouterBeforeRouteHookContext<TRoutes extends Routes, TRejections extends PropertyKey> = RouterHookContext<TRoutes, TRejections> & {
-    abort: CallbackContextAbort;
-};
-export type HookContext<TRoutes extends Routes> = {
-    to: RouterResolvedRouteUnion<TRoutes>;
-    from: RouterResolvedRouteUnion<TRoutes> | null;
-};
-export type RouterBeforeRouteHook<TRoutes extends Routes, TRejections extends PropertyKey> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
-export type AddRouterBeforeRouteHook<TRoutes extends Routes, TRejections extends PropertyKey> = (hook: RouterBeforeRouteHook<TRoutes, TRejections>) => RouteHookRemove;
-type RouterAfterRouteHookContext<TRoutes extends Routes, TRejections extends PropertyKey> = RouterHookContext<TRoutes, TRejections>;
-export type RouterAfterRouteHook<TRoutes extends Routes, TRejections extends PropertyKey> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
-export type AddRouterAfterRouteHook<TRoutes extends Routes, TRejections extends PropertyKey> = (hook: RouterAfterRouteHook<TRoutes, TRejections>) => RouteHookRemove;
-export type RouterRouteHookBeforeRunner<TRoutes extends Routes> = (context: HookContext<TRoutes>) => Promise<BeforeRouteHookResponse>;
-export type RouterRouteHookAfterRunner<TRoutes extends Routes> = (context: HookContext<TRoutes>) => Promise<AfterRouteHookResponse>;
-export type RouterErrorHookContext<TRoutes extends Routes, TRejections extends PropertyKey> = {
-    to: RouterResolvedRouteUnion<TRoutes>;
-    from: RouterResolvedRouteUnion<TRoutes> | null;
-    source: 'props' | 'hook' | 'component';
-    reject: RouterReject<TRejections>;
-    push: RouterPush<TRoutes>;
-    replace: RouterReplace<TRoutes>;
-};
-export type RouterErrorHook<TRoutes extends Routes, TRejections extends PropertyKey> = (error: unknown, context: RouterErrorHookContext<TRoutes, TRejections>) => void;
-export type AddRouterErrorHook<TRoutes extends Routes, TRejections extends PropertyKey> = (hook: RouterErrorHook<TRoutes, TRejections>) => RouteHookRemove;
-export type RouterRouteHookErrorRunnerContext<TRoutes extends Routes> = {
-    to: RouterResolvedRouteUnion<TRoutes>;
-    from: RouterResolvedRouteUnion<TRoutes> | null;
-    source: 'props' | 'hook';
-};
-export type RouterRouteHookErrorRunner<TRoutes extends Routes> = (error: unknown, context: RouterRouteHookErrorRunnerContext<TRoutes>) => void;
 /**
  * This type is the same as `RouterRoute<ResolvedRoute<TRoutes[number]>>` while remaining distributive
  */
 export type RouterRouteUnion<TRoutes extends Routes> = {
     [K in keyof TRoutes]: RouterRoute<ResolvedRoute<TRoutes[K]>>;
 }[number];
-/**
- * This type is the same as `ResolvedRoute<TRoutes[number]>` while remaining distributive
- */
-type RouterResolvedRouteUnion<TRoutes extends Routes> = {
-    [K in keyof TRoutes]: ResolvedRoute<TRoutes[K]>;
-}[number];
 export type RouterRoutes<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? TRoutes : Routes;
-export type RouterRejections<TRouter extends Router> = TRouter extends Router<any, infer TOptions extends RouterOptions, infer TPlugins extends RouterPlugin> ? keyof TOptions['rejections'] | KeysOfUnion<TPlugins['rejections']> : PropertyKey;
+export type RouterRejections<TRouter extends Router> = TRouter extends Router<any, infer TOptions extends RouterOptions, infer TPlugins extends RouterPlugin> ? ExtractRejections<TOptions> | ExtractRejections<TPlugins> : [];
 export type RouterRouteName<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? RoutesName<TRoutes> : RoutesName<Route[]>;
-export {};

package/dist/types/routerPlugin.d.ts

@@ -1,18 +1,114 @@
-import { Component } from 'vue';
-import { BeforeRouteHook, AfterRouteHook } from './hooks';
+import { BeforeRouteHook, AfterRouteHook, RouteHookRemove } from './hooks';
 import { Routes } from './route';
-import { MaybeArray } from './utilities';
-export type EmptyRouterPlugin = {
-    routes: [];
-    rejections: {};
-};
-export type RouterPlugin<TRoutes extends Routes = Routes, TRejections extends Record<string, Component> = Record<string, Component>> = {
-    routes: TRoutes;
-    rejections: TRejections;
+import { MaybeArray, MaybePromise } from './utilities';
+import { Rejection } from './rejection';
+import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { ResolvedRoute } from './resolved';
+import { RouterReject } from './routerReject';
+import { RouterPush } from './routerPush';
+import { RouterReplace } from './routerReplace';
+import { CallbackContextAbort } from '../services/createRouterCallbackContext';
+export type EmptyRouterPlugin = RouterPlugin<[], []>;
+export type CreateRouterPluginOptions<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+    routes?: TRoutes;
+    rejections?: TRejections;
+    /**
+     * @deprecated use plugin.onBeforeRouteEnter instead
+     */
     onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
+    /**
+     * @deprecated use plugin.onAfterRouteEnter instead
+     */
     onAfterRouteEnter?: MaybeArray<AfterRouteHook>;
+    /**
+     * @deprecated use plugin.onBeforeRouteUpdate instead
+     */
     onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
+    /**
+     * @deprecated use plugin.onAfterRouteUpdate instead
+     */
     onAfterRouteUpdate?: MaybeArray<AfterRouteHook>;
+    /**
+     * @deprecated use plugin.onBeforeRouteLeave instead
+     */
     onBeforeRouteLeave?: MaybeArray<BeforeRouteHook>;
+    /**
+     * @deprecated use plugin.onAfterRouteLeave instead
+     */
     onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
 };
+export type RouterPlugin<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+    /**
+     * The routes supplied by the plugin.
+     * @internal
+    */
+    routes: TRoutes;
+    /**
+    * The rejections supplied by the plugin.
+     * @internal
+     */
+    rejections: TRejections;
+    /**
+     * The hooks supplied by the plugin.
+     * @internal
+     */
+    hooks: RouterRouteHooks;
+};
+type PluginBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Rejection[]> = {
+    from: ResolvedRoute | null;
+    reject: RouterReject<TRejections>;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+    abort: CallbackContextAbort;
+};
+type PluginAfterRouteHookContext<TRoutes extends Routes, TRejections extends Rejection[]> = {
+    from: ResolvedRoute | null;
+    reject: RouterReject<TRejections>;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+};
+export type PluginBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (to: ResolvedRoute, context: PluginBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+export type PluginAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (to: ResolvedRoute, context: PluginAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+type AddPluginBeforeRouteHook<TRoutes extends Routes, TRejections extends Rejection[]> = (hook: PluginBeforeRouteHook<TRoutes, TRejections>) => RouteHookRemove;
+type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejection[]> = (hook: PluginAfterRouteHook<TRoutes, TRejections>) => RouteHookRemove;
+export type PluginErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+    to: ResolvedRoute;
+    from: ResolvedRoute | null;
+    source: 'props' | 'hook' | 'component';
+    reject: RouterReject<TRejections>;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+};
+export type PluginErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (error: unknown, context: PluginErrorHookContext<TRoutes, TRejections>) => void;
+export type AddPluginErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = (hook: PluginErrorHook<TRoutes, TRejections>) => RouteHookRemove;
+export type PluginRouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+    /**
+     * Registers a global hook to be called before a route is entered.
+     */
+    onBeforeRouteEnter: AddPluginBeforeRouteHook<TRoutes, TRejections>;
+    /**
+     * Registers a global hook to be called before a route is left.
+     */
+    onBeforeRouteLeave: AddPluginBeforeRouteHook<TRoutes, TRejections>;
+    /**
+     * Registers a global hook to be called before a route is updated.
+     */
+    onBeforeRouteUpdate: AddPluginBeforeRouteHook<TRoutes, TRejections>;
+    /**
+     * Registers a global hook to be called after a route is entered.
+     */
+    onAfterRouteEnter: AddPluginAfterRouteHook<TRoutes, TRejections>;
+    /**
+     * Registers a global hook to be called after a route is left.
+     */
+    onAfterRouteLeave: AddPluginAfterRouteHook<TRoutes, TRejections>;
+    /**
+     * Registers a global hook to be called after a route is updated.
+     */
+    onAfterRouteUpdate: AddPluginAfterRouteHook<TRoutes, TRejections>;
+    /**
+     * Registers a global hook to be called when an error occurs.
+     */
+    onError: AddPluginErrorHook<TRoutes, TRejections>;
+};
+export {};

package/dist/types/routerReject.d.ts

@@ -1,3 +1,3 @@
 import { BuiltInRejectionType } from '../services/createRouterReject';
-import { AsString } from './utilities';
-export type RouterReject<TRejectionType extends PropertyKey> = (type: AsString<TRejectionType> | BuiltInRejectionType) => void;
+import { Rejection, RejectionType } from './rejection';
+export type RouterReject<TRejections extends Rejection[] | undefined> = <TSource extends (RejectionType<TRejections> | BuiltInRejectionType)>(type: TSource) => void;