@kitbag/router 0.20.7 → 0.20.9

package/dist/services/createRouterCallbackContext.d.ts

@@ -0,0 +1,45 @@
+import { Router, RouterRejections, RouterRoutes } from '../types/router';
+import { RouterPush } from '../types/routerPush';
+import { RouterReject } from '../types/routerReject';
+import { RouterReplace } from '../types/routerReplace';
+import { InjectionKey } from 'vue';
+import { BuiltInRejectionType } from './createRouterReject';
+import { AsString } from '../types/utilities';
+import { Routes } from '../types/route';
+/**
+ * Defines the structure of a successful callback response.
+ */
+export type RouterCallbackSuccessResponse = {
+    status: 'SUCCESS';
+};
+/**
+ * Defines the structure of an aborted callback response.
+ */
+export type RouterCallbackAbortResponse = {
+    status: 'ABORT';
+};
+/**
+ * Defines the structure of a callback response that results in a push to a new route.
+ */
+export type RouterCallbackPushResponse<TRoutes extends Routes> = {
+    status: 'PUSH';
+    to: Parameters<RouterPush<TRoutes>>;
+};
+/**
+ * Defines the structure of a callback response that results in the rejection of a route transition.
+ */
+export type RouterCallbackRejectResponse<TRejections extends PropertyKey> = {
+    status: 'REJECT';
+    type: AsString<TRejections> | BuiltInRejectionType;
+};
+/**
+ * A function that can be called to abort a routing operation.
+ */
+export type CallbackContextAbort = () => void;
+export type RouterCallbackContext<TRouter extends Router> = {
+    reject: RouterReject<RouterRejections<TRouter>>;
+    push: RouterPush<RouterRoutes<TRouter>>;
+    replace: RouterReplace<RouterRoutes<TRouter>>;
+    abort: CallbackContextAbort;
+};
+export declare function createRouterCallbackContext<TRouter extends Router>(_routerKey: InjectionKey<TRouter>): RouterCallbackContext<TRouter>;

package/dist/services/createRouterHooks.d.ts

@@ -1,20 +1,20 @@
 import { AddGlobalRouteHooks, AddComponentAfterRouteHook, AddComponentBeforeRouteHook } from '../types/hooks';
 import { HasVueAppStore } from './createVueAppStore';
-import { AddRouterAfterRouteHook, AddRouterBeforeRouteHook, Router, RouterRoutes, RouterRouteHookBeforeRunner, RouterRouteHookAfterRunner } from '../types/router';
+import { AddRouterAfterRouteHook, AddRouterBeforeRouteHook, Router, RouterRoutes, RouterRouteHookBeforeRunner, RouterRouteHookAfterRunner, RouterRejections } from '../types/router';
 import { Routes } from '../types/route';
 import { InjectionKey } from 'vue';
-export declare const getRouterHooksKey: (routerKey: InjectionKey<Router>) => InjectionKey<RouterHooks<any>>;
-export type RouterHooks<TRoutes extends Routes> = HasVueAppStore & {
+export declare const getRouterHooksKey: (routerKey: InjectionKey<Router>) => InjectionKey<RouterHooks<any, any>>;
+export type RouterHooks<TRoutes extends Routes, TRejections extends PropertyKey> = HasVueAppStore & {
     runBeforeRouteHooks: RouterRouteHookBeforeRunner<TRoutes>;
     runAfterRouteHooks: RouterRouteHookAfterRunner<TRoutes>;
-    addComponentBeforeRouteHook: AddComponentBeforeRouteHook<TRoutes>;
-    addComponentAfterRouteHook: AddComponentAfterRouteHook<TRoutes>;
-    addGlobalRouteHooks: AddGlobalRouteHooks<TRoutes>;
-    onBeforeRouteEnter: AddRouterBeforeRouteHook<TRoutes>;
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes>;
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes>;
-    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes>;
-    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes>;
-    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes>;
+    addComponentBeforeRouteHook: AddComponentBeforeRouteHook<TRoutes, TRejections>;
+    addComponentAfterRouteHook: AddComponentAfterRouteHook<TRoutes, TRejections>;
+    addGlobalRouteHooks: AddGlobalRouteHooks<TRoutes, TRejections>;
+    onBeforeRouteEnter: AddRouterBeforeRouteHook<TRoutes, TRejections>;
+    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes, TRejections>;
+    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes, TRejections>;
+    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes, TRejections>;
+    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes, TRejections>;
+    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes, TRejections>;
 };
-export declare function createRouterHooks<TRouter extends Router>(_routerKey: InjectionKey<TRouter>): RouterHooks<RouterRoutes<TRouter>>;
+export declare function createRouterHooks<TRouter extends Router>(_routerKey: InjectionKey<TRouter>): RouterHooks<RouterRoutes<TRouter>, RouterRejections<TRouter>>;

package/dist/services/getGlobalRouteHooks.d.ts

@@ -1,5 +1,5 @@
 import { ResolvedRoute } from '../types/resolved';
 import { RouterRouteHooks } from '../models/RouterRouteHooks';
 import { Routes } from '../main';
-export declare function getGlobalBeforeRouteHooks<TRoutes extends Routes>(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: RouterRouteHooks<TRoutes>): RouterRouteHooks<TRoutes>;
-export declare function getGlobalAfterRouteHooks<TRoutes extends Routes>(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: RouterRouteHooks<TRoutes>): RouterRouteHooks<TRoutes>;
+export declare function getGlobalBeforeRouteHooks<TRoutes extends Routes, TRejections extends PropertyKey>(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: RouterRouteHooks<TRoutes, TRejections>): RouterRouteHooks<TRoutes, TRejections>;
+export declare function getGlobalAfterRouteHooks<TRoutes extends Routes, TRejections extends PropertyKey>(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: RouterRouteHooks<TRoutes, TRejections>): RouterRouteHooks<TRoutes, TRejections>;

package/dist/services/getRouteHooks.d.ts

@@ -1,4 +1,10 @@
 import { RouteHooks } from '../models/RouteHooks';
 import { ResolvedRoute } from '../types/resolved';
+/**
+ * @deprecated will be removed in a future version
+ */
 export declare function getBeforeRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): RouteHooks;
+/**
+ * @deprecated will be removed in a future version
+ */
 export declare function getAfterRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): RouteHooks;

package/dist/types/hooks.d.ts

@@ -8,11 +8,29 @@ import { RouterAfterRouteHook, RouterBeforeRouteHook } from './router';
  * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
  */
 export type WithHooks = {
+    /**
+     * @deprecated Use router.onBeforeRouteEnter instead
+     */
     onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
+    /**
+     * @deprecated Use router.onBeforeRouteUpdate instead
+     */
     onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
+    /**
+     * @deprecated Use router.onBeforeRouteLeave instead
+     */
     onBeforeRouteLeave?: MaybeArray<BeforeRouteHook>;
+    /**
+     * @deprecated Use router.onAfterRouteEnter instead
+     */
     onAfterRouteEnter?: MaybeArray<AfterRouteHook>;
+    /**
+     * @deprecated Use router.onAfterRouteUpdate instead
+     */
     onAfterRouteUpdate?: MaybeArray<AfterRouteHook>;
+    /**
+     * @deprecated Use router.onAfterRouteLeave instead
+     */
     onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
 };
 export type BeforeHookContext = {
@@ -26,19 +44,19 @@ export type AfterHookContext = {
 };
 export type RouteHookAfterRunner = (context: AfterHookContext) => Promise<AfterRouteHookResponse>;
 export type RouteHookTiming = 'global' | 'component';
-export type BeforeRouteHookRegistration<TRoutes extends Routes> = {
+type BeforeRouteHookRegistration<TRoutes extends Routes, TRejections extends PropertyKey> = {
     lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
-    hook: RouterBeforeRouteHook<TRoutes>;
+    hook: RouterBeforeRouteHook<TRoutes, TRejections>;
     depth: number;
 };
-export type AddComponentBeforeRouteHook<TRoutes extends Routes> = (hook: BeforeRouteHookRegistration<TRoutes>) => RouteHookRemove;
-export type AfterRouteHookRegistration<TRoutes extends Routes> = {
+export type AddComponentBeforeRouteHook<TRoutes extends Routes, TRejections extends PropertyKey> = (hook: BeforeRouteHookRegistration<TRoutes, TRejections>) => RouteHookRemove;
+type AfterRouteHookRegistration<TRoutes extends Routes, TRejections extends PropertyKey> = {
     lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
-    hook: RouterAfterRouteHook<TRoutes>;
+    hook: RouterAfterRouteHook<TRoutes, TRejections>;
     depth: number;
 };
-export type AddComponentAfterRouteHook<TRoutes extends Routes> = (hook: AfterRouteHookRegistration<TRoutes>) => RouteHookRemove;
-export type AddGlobalRouteHooks<TRoutes extends Routes> = (hooks: RouterRouteHooks<TRoutes>) => void;
+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;
 /**
  * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
  */

package/dist/types/register.d.ts

@@ -3,6 +3,7 @@ import { Route, Routes } from './route';
 import { Router, RouterOptions } from './router';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
+import { RoutesName } from './routesMap';
 /**
  * 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.
@@ -27,12 +28,14 @@ export type RegisteredRouter<T = Register> = T extends {
 } ? TRouter : Router;
 /**
  * Represents the Router routes property within {@link Register}
+ * @deprecated will be removed in a future version
  */
 export type RegisteredRoutes<T = Register> = T extends {
     router: Router<infer TRoutes extends Routes>;
 } ? TRoutes : Route[];
 /**
  * Represents the possible Rejections registered within {@link Register}
+ * @deprecated use `createRouter(..., { rejections: {}}) instead
  */
 export type RegisteredRejectionType<T = Register> = T extends {
     router: Router<any, infer TOptions extends RouterOptions>;
@@ -45,13 +48,21 @@ export type RouteMeta<T = Register> = T extends {
 } ? RouteMeta : Record<string, unknown>;
 /**
  * Represents the type for router `push`, with types for routes registered within {@link Register}
+ * @deprecated will be removed in a future version
  */
 export type RegisteredRouterPush = RouterPush<RegisteredRoutes>;
 /**
  * Represents the type for router `replace`, with types for routes registered within {@link Register}
+ * @deprecated will be removed in a future version
  */
 export type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
 /**
  * Type for Router Reject method. Triggers rejections registered within {@link Register}
+ * @deprecated will be removed in a future version
  */
 export type RegisteredRouterReject = (type: RegisteredRejectionType) => void;
+/**
+ * Represents the union of all possible route names registered within {@link Register}
+ * @deprecated will be removed in a future version
+ */
+export type RegisteredRoutesName = RoutesName<RegisteredRoutes>;

package/dist/types/router.d.ts

@@ -12,7 +12,7 @@ import { RouterReject } from './routerReject';
 import { RouterPlugin } from './routerPlugin';
 import { KeysOfUnion, MaybePromise } from './utilities';
 import { RoutesName } from './routesMap';
-import { AfterRouteHookResponse, BeforeRouteHookResponse, RegisteredRouterReject } from '../main';
+import { AfterRouteHookResponse, BeforeRouteHookResponse } from '../main';
 import { CallbackContextAbort } from '../services/createCallbackContext';
 /**
  * Options to initialize a {@link Router} instance.
@@ -100,27 +100,27 @@ 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']>;
+    onBeforeRouteEnter: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called before a route is left.
      */
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes']>;
+    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called before a route is updated.
      */
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes']>;
+    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is entered.
      */
-    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes | TPlugin['routes']>;
+    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is left.
      */
-    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes | TPlugin['routes']>;
+    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
     /**
      * Registers a hook to be called after a route is updated.
      */
-    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes | TPlugin['routes']>;
+    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes | TPlugin['routes'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
     /**
     * Given a URL, returns true if host does not match host stored on router instance
     */
@@ -148,24 +148,24 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      */
     key: InjectionKey<Router<TRoutes, TOptions, TPlugin>>;
 };
-type RouterHookContext<TRoutes extends Routes> = {
+type RouterHookContext<TRoutes extends Routes, TRejections extends PropertyKey> = {
     from: RouterResolvedRouteUnion<TRoutes> | null;
-    reject: RegisteredRouterReject;
+    reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
 };
-type RouterBeforeRouteHookContext<TRoutes extends Routes> = RouterHookContext<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> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterBeforeRouteHookContext<TRoutes>) => MaybePromise<void>;
-export type AddRouterBeforeRouteHook<TRoutes extends Routes> = (hook: RouterBeforeRouteHook<TRoutes>) => RouteHookRemove;
-type RouterAfterRouteHookContext<TRoutes extends Routes> = RouterHookContext<TRoutes>;
-export type RouterAfterRouteHook<TRoutes extends Routes> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterAfterRouteHookContext<TRoutes>) => MaybePromise<void>;
-export type AddRouterAfterRouteHook<TRoutes extends Routes> = (hook: RouterAfterRouteHook<TRoutes>) => RouteHookRemove;
+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>;
 /**
@@ -181,5 +181,6 @@ 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 RouterRouteName<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? RoutesName<TRoutes> : RoutesName<Route[]>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kitbag/router",
   "private": false,
-  "version": "0.20.7",
+  "version": "0.20.9",
   "bugs": {
     "url": "https://github.com/kitbagjs/router/issues"
   },
@@ -17,7 +17,7 @@
   "scripts": {
     "build": "vite build",
     "build:watch": "vite build --watch --minify=false",
-    "test": "vitest --typecheck",
+    "test": "vitest",
     "lint": "eslint ./src",
     "lint:fix": "eslint ./src --fix",
     "types": "vue-tsc --noEmit",
@@ -43,9 +43,9 @@
     "@kitbag/eslint-config": "1.0.2",
     "@vitejs/plugin-vue": "^6.0.1",
     "@vue/test-utils": "^2.4.6",
-    "eslint": "^9.38.0",
-    "globals": "^16.4.0",
-    "happy-dom": "^20.0.7",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
+    "happy-dom": "^20.0.8",
     "typedoc": "^0.28.14",
     "typedoc-plugin-markdown": "^4.9.0",
     "typedoc-vitepress-theme": "^1.1.2",
@@ -54,7 +54,7 @@
     "vite": "^7.1.12",
     "vite-plugin-dts": "^4.5.4",
     "vitepress": "^1.6.4",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.4",
     "vue-tsc": "^3.1.2"
   },
   "peerDependencies": {