@kitbag/router 0.28.0 → 0.29.0

package/dist/types/register.d.ts

@@ -19,8 +19,8 @@ export interface Register {
  * Represents the Router property within {@link Register}
  */
 export type RegisteredRouter<T = Register> = T extends {
-    router: infer TRouter;
-} ? TRouter : Router;
+    router: unknown;
+} ? T['router'] : Router;
 /**
  * Represents additional metadata associated with a route, customizable via declaration merging.
  */

package/dist/types/resolved.d.ts

@@ -105,4 +105,8 @@ export type RouterResolvedRouteUnion<TRoutes extends Routes> = {
  * type ResolvedUnion = ResolvedRouteUnion<RouteUnion> // ResolvedRoute<RouteA> | ResolvedRoute<RouteB>
  */
 export type ResolvedRouteUnion<TRoute extends Route> = TRoute extends Route ? ResolvedRoute<TRoute> : never;
+/**
+ * Converts a route union to resolved routes with their corresponding loader data.
+ */
+export type ResolvedRouteWithDataUnion<TRoute extends Route> = TRoute extends Route ? ResolvedRoute<TRoute> & WithData<TRoute> : never;
 export {};

package/dist/types/routeContext.d.ts

@@ -3,6 +3,14 @@ import { Rejection, Rejections } from './rejection';
 import { GenericRoute, Route, Routes } from './route';
 export type RouteContext = GenericRoute | Rejection;
 export type ToRouteContext<TContext extends RouteContext[] | readonly RouteContext[] | undefined> = TContext extends RouteContext[] ? TContext : [];
+/**
+ * Adds context to an options type while preserving its existing properties and context.
+ */
+export type WithRouteContext<TOptions extends {
+    context?: RouteContext[];
+}, TContext extends RouteContext[]> = TContext extends [] ? TOptions : Omit<TOptions, 'context'> & {
+    context: [...ToRouteContext<TOptions['context']>, ...TContext];
+};
 export type ExtractRouteContext<TOptions extends CreateRouteOptions> = TOptions extends {
     context: infer TContext extends RouteContext[];
 } ? TOptions extends {

package/dist/types/routeWithParams.d.ts

@@ -2,4 +2,4 @@ import { Route, Routes } from './route';
 import { RoutesName, RoutesMap } from './routesMap';
 import { UrlParamsWriting } from './url';
 export type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesName<TRoutes>> = RoutesMap<TRoutes>[TKey];
-export type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = RouteGetByKey<TRoutes, TKey> extends Route ? UrlParamsWriting<RouteGetByKey<TRoutes, TKey>> : Record<string, unknown>;
+export type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = TKey extends string ? RouteGetByKey<TRoutes, TKey> extends Route ? UrlParamsWriting<RouteGetByKey<TRoutes, TKey>> : Record<string, unknown> : never;

package/dist/types/router.d.ts

@@ -6,7 +6,7 @@ import { RouterRoute } from './routerRoute';
 import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from './hooks';
 import { PrefetchConfig } from './prefetch';
 import { ResolvedRoute } from './resolved';
-import { Route, Routes } from './route';
+import { Routes } from './route';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
 import { RouterResolve, RouterResolveOptions } from './routerResolve';
@@ -256,7 +256,8 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      */
     render: () => Promise<ServerRenderResponse>;
     /**
-     * Stops the router. Tears down the history listener and ignores any navigation still in flight or started afterwards.
+     * Stops the router. Releases history listeners and context subscriptions and ignores any navigation
+     * still in flight or started afterwards. Called automatically when the Vue app unmounts.
      */
     stop: () => void;
     /**
@@ -278,6 +279,6 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
 export type RouterRouteUnion<TRoutes extends Routes> = {
     [K in keyof TRoutes]: TRoutes[K]['name'] extends '' ? never : RouterRoute<ResolvedRoute<TRoutes[K]>>;
 }[number];
-export type RouterRoutes<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? TRoutes : Routes;
+export type RouterRoutes<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes, any, infer TPlugin extends RouterPlugin> ? Routes extends TRoutes | TPlugin['routes'] ? Routes : TRoutes | TPlugin['routes'] : Routes;
 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 type RouterRouteName<TRouter extends Router> = RoutesName<RouterRoutes<TRouter>>;

package/dist/types/routerPlugin.d.ts

@@ -1,4 +1,4 @@
-import { HookRemove } from './hooks';
+import { AddHook, HookRemove } from './hooks';
 import { Routes } from './route';
 import { Rejections } from './rejection';
 import { Hooks } from '../models/hooks';
@@ -30,6 +30,7 @@ export type RouterPlugin<TRoutes extends Routes = Routes, TRejections extends Re
     rejections: TRejections;
 };
 type PluginBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Rejections> = {
+    lifecycle: 'before';
     from: ResolvedRoute | null;
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
@@ -37,6 +38,7 @@ type PluginBeforeRouteHookContext<TRoutes extends Routes, TRejections extends Re
     abort: CallbackContextAbort;
 };
 type PluginAfterRouteHookContext<TRoutes extends Routes, TRejections extends Rejections> = {
+    lifecycle: 'after';
     from: ResolvedRoute | null;
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
@@ -44,12 +46,12 @@ type PluginAfterRouteHookContext<TRoutes extends Routes, TRejections extends Rej
 };
 export type PluginBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute, context: PluginBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
 export type PluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute | null, context: PluginBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
-type AddPluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: PluginBeforeRouteLeaveHook<TRoutes, TRejections>) => HookRemove;
+type AddPluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = AddHook<PluginBeforeRouteLeaveHook<TRoutes, TRejections>>;
 export type PluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute | null, context: PluginAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
-type AddPluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: PluginAfterRouteLeaveHook<TRoutes, TRejections>) => HookRemove;
+type AddPluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = AddHook<PluginAfterRouteLeaveHook<TRoutes, TRejections>>;
 export type PluginAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute, context: PluginAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
-type AddPluginBeforeRouteHook<TRoutes extends Routes, TRejections extends Rejections> = (hook: PluginBeforeRouteHook<TRoutes, TRejections>) => HookRemove;
-type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejections> = (hook: PluginAfterRouteHook<TRoutes, TRejections>) => HookRemove;
+type AddPluginBeforeRouteHook<TRoutes extends Routes, TRejections extends Rejections> = AddHook<PluginBeforeRouteHook<TRoutes, TRejections>>;
+type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejections> = AddHook<PluginAfterRouteHook<TRoutes, TRejections>>;
 export type PluginErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     to: ResolvedRoute | null;
     from: ResolvedRoute | null;

package/dist/types/url.d.ts

@@ -9,6 +9,7 @@ export type UrlInternal = {
     [IS_URL_SYMBOL]: true;
     schema: Record<string, UrlPart>;
     params: {};
+    isMatch: (url: string, options?: ParseUrlOptions) => boolean;
 };
 export type CreateUrlOptions = {
     host?: string | UrlPart | undefined;

package/dist/types/view.d.ts

@@ -0,0 +1,58 @@
+import { Component } from 'vue';
+import { ComponentProps } from '../services/component';
+import { TransformerOptions } from '../services/payload';
+import { PrefetchConfig } from './prefetch';
+import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { ResolvedRouteWithDataUnion } from './resolved';
+import { Routes } from './route';
+import { RouterPush } from './routerPush';
+import { RouterReplace } from './routerReplace';
+import { RouterReject } from './routerReject';
+import { AnyFunction, MaybePromise } from './utilities';
+export declare const IS_VIEW_SYMBOL: unique symbol;
+export type ViewInternal = {
+    [IS_VIEW_SYMBOL]: true;
+};
+/**
+ * Navigation helpers available to a reusable view from its declared context.
+ */
+export type ViewCallbackContext<TContext extends readonly RouteContext[] = []> = {
+    push: RouterPush<RouteContextToRoute<[...TContext]>>;
+    replace: RouterReplace<RouteContextToRoute<[...TContext]>>;
+    reject: RouterReject<RouteContextToRejection<[...TContext]>>;
+    signal: AbortSignal;
+};
+export type ViewPropsGetter<TContext extends readonly RouteContext[], TProps, TRoutes extends Routes = Routes> = (route: ResolvedRouteWithDataUnion<TRoutes[number]>, context: ViewCallbackContext<TContext>) => TProps;
+/**
+ * Options for a reusable component and its props getter.
+ */
+export type CreateViewOptions<TComponent extends Component = Component, TContext extends readonly RouteContext[] = [], TProps extends MaybePromise<ComponentProps<TComponent>> | undefined = undefined, TRoutes extends Routes = Routes> = TransformerOptions<NoInfer<Awaited<TProps>>> & {
+    component: TComponent;
+    /**
+     * See [Context](https://kitbag-router.netlify.app/advanced-concepts/context).
+     */
+    context?: TContext;
+    prefetch?: PrefetchConfig;
+} & (Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? {
+    props?: ViewPropsGetter<TContext, TProps extends undefined ? MaybePromise<ComponentProps<TComponent>> : TProps, TRoutes>;
+} : {
+    props: ViewPropsGetter<TContext, TProps extends undefined ? MaybePromise<ComponentProps<TComponent>> : TProps, TRoutes>;
+});
+/**
+ * Creates views with props callbacks typed to the router's resolved routes and loader data.
+ */
+export type CreateView<TRoutes extends Routes = Routes> = <TComponent extends Component, const TContext extends readonly RouteContext[] = [], TProps extends MaybePromise<ComponentProps<TComponent>> | undefined = undefined>(options: CreateViewOptions<TComponent, TContext, TProps, TRoutes>) => View<TProps, TContext>;
+/**
+ * A reusable view definition with its props getter's result and declared context.
+ */
+export type View<TProps = unknown, TContext extends readonly RouteContext[] = []> = TransformerOptions<Awaited<TProps>> & {
+    component: Component;
+    props?: AnyFunction<TProps>;
+    context: TContext;
+    prefetch?: PrefetchConfig;
+};
+export type AnyView = View<any, readonly RouteContext[]>;
+/**
+ * Determines whether a value is a reusable view.
+ */
+export declare function isView(value: unknown): value is AnyView & ViewInternal;

package/dist/utilities/testHelpers.d.ts

@@ -86,8 +86,8 @@ export declare const routes: readonly [import('../types/routeWithMethods').Route
     meta: Readonly<{}>;
     id: string;
     name: "parentA.childB";
-    loaders: {};
     readonly path: "/childB/[paramD]";
+    loaders: {};
     views: {
         default: import('../types/routeViews').RouteView;
     };
@@ -142,8 +142,8 @@ export declare const routes: readonly [import('../types/routeWithMethods').Route
     meta: Readonly<{}>;
     id: string;
     name: "parentA.childA.grandChildA";
-    loaders: {};
     readonly path: "/[paramC]";
+    loaders: {};
     views: {
         default: import('../types/routeViews').RouteView;
     };
@@ -154,8 +154,8 @@ export declare const routes: readonly [import('../types/routeWithMethods').Route
     meta: Readonly<{}>;
     id: string;
     name: "parentB";
-    loaders: {};
     readonly path: "/parentB";
+    loaders: {};
     views: {
         default: import('../types/routeViews').RouteView;
     };
@@ -166,8 +166,8 @@ export declare const routes: readonly [import('../types/routeWithMethods').Route
     meta: Readonly<{}>;
     id: string;
     name: "parentC";
-    loaders: {};
     readonly path: "/";
+    loaders: {};
     views: {
         default: import('../types/routeViews').RouteView;
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kitbag/router",
   "private": false,
-  "version": "0.28.0",
+  "version": "0.29.0",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/kitbagjs/router/issues"

package/dist/services/createRouteRedirects.d.ts

@@ -1,10 +0,0 @@
-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.
-     */
-    getRoute: () => Route;
-};
-export declare function createRouteRedirects({ getRoute }: CreateRouteRedirectsContext): RouteRedirects;
-export {};