@kitbag/router 0.24.2 → 0.25.0

package/dist/{src/types → types}/props.d.ts

@@ -1,11 +1,14 @@
-import { CreateRouteOptions, PropsGetter } from '../../types/createRouteOptions';
-import { Route } from '../../types/route';
+import { CreateRouteOptions } from './createRouteOptions';
+import { Route } from './route';
 import { RouterReject } from './routerReject';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
 import { ExtractRouteContextRejections, ExtractRouteContextRoutes } from './routeContext';
 import { ResolvedRoute } from './resolved';
 import { RouteUpdate } from './routeUpdate';
+import { LoadersDataReturnType } from './routeLoaders';
+import { ViewsPropsReturnType } from './routeViews';
+import { LastInArray } from './utilities';
 /**
  * Context provided to props callback functions
  */
@@ -19,11 +22,16 @@ export type PropsCallbackContext<TRoute extends Route = Route, TOptions extends
 export type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
     name: string;
     props: unknown;
+    data: unknown;
 } : TParent extends Route ? {
     name: TParent['name'];
     props: GetParentPropsReturnType<TParent>;
+    data: GetParentDataReturnType<TParent>;
 } : undefined;
-type GetParentPropsReturnType<TParent extends Route | undefined = Route | undefined> = TParent extends Route ? TParent['matched']['props'] extends PropsGetter ? ReturnType<TParent['matched']['props']> : TParent['matched']['props'] extends Record<string, PropsGetter> ? {
-    [K in keyof TParent['matched']['props']]: ReturnType<TParent['matched']['props'][K]>;
-} : undefined : undefined;
+type GetParentPropsReturnType<TParent extends Route | undefined = Route | undefined> = TParent extends Route ? LastInArray<TParent['matches']> extends {
+    views: infer TViews;
+} ? ViewsPropsReturnType<TViews> : undefined : undefined;
+type GetParentDataReturnType<TParent extends Route | undefined = Route | undefined> = TParent extends Route ? LastInArray<TParent['matches']> extends {
+    loaders: infer TLoaders;
+} ? LoadersDataReturnType<TLoaders> : undefined : undefined;
 export {};

package/dist/{src/types → types}/register.d.ts

@@ -1,4 +1,4 @@
-import { Router } from '../../types/router';
+import { Router } from './router';
 /**
  * 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.

package/dist/{src/types → types}/rejection.d.ts

@@ -1,8 +1,8 @@
 import { Ref } from 'vue';
-import { Route } from '../../types/route';
-import { Router } from '../../types/router';
-import { RouterReject } from '../../types/routerReject';
-import { Hooks } from '../../models/hooks';
+import { Route } from './route';
+import { Router } from './router';
+import { RouterReject } from './routerReject';
+import { Hooks } from '../models/hooks';
 export declare const BUILT_IN_REJECTION_TYPES: readonly ["NotFound"];
 export type BuiltInRejectionType = (typeof BUILT_IN_REJECTION_TYPES)[number];
 export type RouterRejection<T extends Rejection = Rejection> = Ref<T | null>;

package/dist/{src/types → types}/resolved.d.ts

@@ -1,7 +1,13 @@
-import { Route, Routes } from '../../types/route';
-import { ExtractRouteStateParamsAsOptional } from '../../types/state';
-import { UrlString } from '../../types/urlString';
-import { UrlParamsReading } from '../../types/url';
+import { CreatedRouteOptions, Route, RouteDataOf, Routes } from './route';
+import { LastInArray } from './utilities';
+import { ExtractRouteStateParamsAsOptional } from './state';
+import { UrlString } from './urlString';
+import { UrlParamsReading } from './url';
+/**
+ * The match a route resolved to, which is the last of its matches. Falls back to the wide match type when
+ * the matches are not a concrete tuple, so an unregistered router stays assignable.
+ */
+type MatchedRoute<TMatches> = LastInArray<TMatches, CreatedRouteOptions> extends infer TMatched ? unknown extends TMatched ? CreatedRouteOptions : TMatched : never;
 /**
  * Represents a route that the router has matched to current browser location.
  * @template TRoute - Underlying Route that has been resolved.
@@ -14,7 +20,7 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
     /**
      * The specific route properties that were matched in the current route.
     */
-    matched: TRoute['matched'];
+    matched: MatchedRoute<TRoute['matches']>;
     /**
      * The specific route properties that were matched in the current route, including any ancestors.
      * Order of routes will be from greatest ancestor to narrowest matched.
@@ -49,6 +55,18 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      */
     title: Promise<string | undefined>;
 }>;
+/**
+ * A resolved route whose loaders' data is available. Only the route being navigated to has data: a route
+ * the router merely resolved is not being loaded, so data on it could never settle. The current route and
+ * a props getter's route have it, `router.resolve` and hooks do not.
+ */
+export type WithData<TRoute extends Route = Route> = {
+    /**
+     * What the route's loaders resolve to, keyed by loader name. A route whose only loader is unnamed
+     * exposes that loader's data here directly. Always promises, since loaders never block rendering.
+     */
+    data: RouteDataOf<TRoute['matches']>;
+};
 /**
  * This type is the same as `ResolvedRoute<TRoutes[number]>` while remaining distributive
  */
@@ -65,3 +83,4 @@ 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;
+export {};

package/dist/types/route.d.ts

@@ -0,0 +1,121 @@
+import { Param } from './paramTypes';
+import { PrefetchConfig } from './prefetch';
+import { RouteMeta } from './register';
+import { LastInArray } from './utilities';
+import { CreateRouteOptions } from './createRouteOptions';
+import { RouteContext, ToRouteContext } from './routeContext';
+import { ToMeta } from './meta';
+import { ToState } from './state';
+import { Url } from './url';
+import { GetRouteTitle } from './routeTitle';
+import { Hooks } from '../models/hooks';
+import { RouteRedirect } from './redirects';
+import { RouteViews } from './routeViews';
+import { LoadersDataReturnType, RouteLoaders } from './routeLoaders';
+export declare const IS_ROUTE_SYMBOL: unique symbol;
+export declare function isRoute(value: unknown): value is Route & RouteInternal;
+export type RouteInternal = {
+    [IS_ROUTE_SYMBOL]: true;
+    depth: number;
+    hooks: Hooks[];
+    redirect: RouteRedirect;
+    getTitle: GetRouteTitle;
+};
+/**
+ * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
+ */
+export type Routes = readonly Route[];
+/**
+ * The Route properties originally provided to `createRoute`, plus the views that route renders and the
+ * loaders it runs. The deprecated `component`/`components` options are folded into `views` (see
+ * {@link RouteViews}).
+ */
+export type CreatedRouteOptions = Omit<CreateRouteOptions, 'component' | 'components'> & {
+    id: string;
+    views: RouteViews;
+    loaders: RouteLoaders;
+};
+/**
+ * The name of the narrowest matched route.
+ */
+type RouteNameOf<TMatches extends CreatedRouteOptions[]> = LastInArray<TMatches> extends {
+    name: infer TName extends string;
+} ? TName : string;
+/**
+ * The meta of every matched route, combined. Mirrors `combineMeta`, which is an intersection.
+ */
+type RouteMetaOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteMeta : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? ToMeta<THead extends {
+    meta: infer TMeta extends RouteMeta;
+} ? TMeta : undefined> & RouteMetaOf<TRest> : {};
+/**
+ * The state of every matched route, combined. Mirrors `combineState`, which is an intersection.
+ * A match without state contributes `{}` rather than `ToState<undefined>`, which widens to
+ * `Record<string, Param>` and would swallow the rest of the intersection.
+ */
+type RouteStateOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? Record<string, Param> : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? (THead extends {
+    state: infer TState extends Record<string, Param>;
+} ? ToState<TState> : {}) & RouteStateOf<TRest> : {};
+/**
+ * The loaders of every matched route, combined. A plain intersection: a loader name is unique across a
+ * route and its ancestors, which `addLoader` enforces.
+ */
+type RouteLoadersOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteLoaders : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? (THead extends {
+    loaders: infer TLoaders extends RouteLoaders;
+} ? TLoaders : {}) & RouteLoadersOf<TRest> : {};
+/**
+ * The data every matched route's loaders resolve to, which is what a resolved route exposes as `data`.
+ * Undefined when nothing in the route tree declares a loader.
+ */
+export type RouteDataOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? Promise<unknown> | Record<string, Promise<unknown>> | undefined : LoadersDataReturnType<RouteLoadersOf<TMatches>>;
+/**
+ * The context of every matched route, flattened from greatest ancestor to narrowest matched.
+ */
+type RouteContextOf<TMatches extends CreatedRouteOptions[]> = CreatedRouteOptions[] extends TMatches ? RouteContext[] : TMatches extends [infer THead, ...infer TRest extends CreatedRouteOptions[]] ? [...ToRouteContext<THead extends {
+    context: infer TContext extends RouteContext[];
+} ? TContext : []>, ...RouteContextOf<TRest>] : [];
+/**
+ * Represents the structure of a route within the application. Return value of `createRoute`
+ * @template TUrl - The url the route resolves to, combined with any parents. Intersected into the route.
+ * @template TMatches - The options of the route and its ancestors, indexed by depth. Name, meta, state,
+ * and context are all derived from this, including each route's views.
+ */
+export type Route<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = TUrl & {
+    /**
+     * Unique identifier for the route, generated by router.
+    */
+    id: string;
+    /**
+     * The specific route properties that were matched in the current route, including any ancestors.
+     * Order of routes will be from greatest ancestor to narrowest matched.
+    */
+    matches: TMatches;
+    /**
+     * Identifier for the route as defined by user. Name must be unique among named routes. Name is used for routing and for matching.
+    */
+    name: RouteNameOf<TMatches>;
+    /**
+     * Represents additional metadata associated with a route, combined with any parents.
+    */
+    meta: RouteMetaOf<TMatches>;
+    /**
+     * Represents the schema of the route state, combined with any parents.
+    */
+    state: RouteStateOf<TMatches>;
+    /**
+     * 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: RouteContextOf<TMatches>;
+};
+export type GenericRoute = Url & {
+    id: string;
+    name: string;
+    matches: CreatedRouteOptions[];
+    meta: RouteMeta;
+    state: Record<string, Param>;
+    prefetch?: PrefetchConfig;
+};
+export {};

package/dist/types/routeCallbackContext.d.ts

@@ -0,0 +1,30 @@
+import { ResolvedRoute } from './resolved';
+import { CreatedRouteOptions, Route } from './route';
+import { RouteContextToRejection, RouteContextToRoute } from './routeContext';
+import { RouterPush } from './routerPush';
+import { RouterReject } from './routerReject';
+import { RouterReplace } from './routerReplace';
+import { RouteUpdate } from './routeUpdate';
+import { LoadersDataReturnType } from './routeLoaders';
+import { ViewsPropsReturnType } from './routeViews';
+/**
+ * Context provided to a callback attached to a route — an `addView` props getter, or a loader. Sourced
+ * from the route: rejections/routes from the route's context, and the parent from the route's `matches`.
+ */
+export type RouteCallbackContext<TRoute extends Route> = {
+    reject: RouterReject<RouteContextToRejection<TRoute['context']>>;
+    push: RouterPush<[TRoute] | RouteContextToRoute<TRoute['context']>>;
+    replace: RouterReplace<[TRoute] | RouteContextToRoute<TRoute['context']>>;
+    update: RouteUpdate<ResolvedRoute<TRoute>>;
+    parent: RouteCallbackParent<TRoute>;
+};
+/**
+ * The parent context ({ name, props, data }) reconstructed from the second-to-last `matches` entry, which
+ * carries the parent's name, its views and its loaders.
+ */
+type RouteCallbackParent<TRoute extends Route> = TRoute['matches'] extends [...CreatedRouteOptions[], infer TParent extends CreatedRouteOptions, CreatedRouteOptions] ? {
+    name: TParent['name'];
+    props: ViewsPropsReturnType<TParent['views']>;
+    data: LoadersDataReturnType<TParent['loaders']>;
+} : undefined;
+export {};

package/dist/types/routeLoaders.d.ts

@@ -0,0 +1,30 @@
+import { PrefetchConfig } from './prefetch';
+import { AnyFunction } from './utilities';
+/**
+ * A single loader: how to load its data, and how to prefetch it. Unlike a view, a loader always has a
+ * getter — a loader without one would have nothing to contribute.
+ *
+ * @template TData - What this loader's getter returns, carried so a route's data can be typed from it.
+ */
+export type RouteLoader<TData = unknown> = {
+    load: AnyFunction<TData>;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The loaders for a single route, keyed by loader name (the unnamed loader under 'default').
+ */
+export type RouteLoaders = Record<string, RouteLoader>;
+/**
+ * The data a set of loaders resolves to. A lone unnamed loader is given directly rather than under a
+ * 'default' key, matching how the loader is written. Each loader's data is always a promise, since a
+ * loader never blocks rendering, even when the loader itself is synchronous.
+ */
+export type LoadersDataReturnType<TLoaders> = keyof TLoaders extends never ? undefined : keyof TLoaders extends 'default' ? LoaderData<Extract<TLoaders, {
+    default: unknown;
+}>['default']> : {
+    [K in keyof TLoaders]: LoaderData<TLoaders[K]>;
+};
+type LoaderData<TLoader> = TLoader extends {
+    load: AnyFunction<infer TData>;
+} ? Promise<Awaited<TData>> : never;
+export {};

package/dist/{src/types → types}/routeTitle.d.ts

@@ -1,4 +1,4 @@
-import { ResolvedRoute, ResolvedRouteUnion } from '../../types/resolved';
+import { ResolvedRoute, ResolvedRouteUnion } from './resolved';
 import { Route } from './route';
 import { MaybePromise } from './utilities';
 export type SetRouteTitleContext = {

package/dist/{src/types → types}/routeUpdate.d.ts

@@ -1,5 +1,5 @@
-import { ResolvedRoute } from '../../types/resolved';
-import { RouterPushOptions } from '../../types/routerPush';
+import { ResolvedRoute } from './resolved';
+import { RouterPushOptions } from './routerPush';
 export type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = ResolvedRoute extends TRoute ? {
     (paramName: string, paramValue: unknown, options?: RouterPushOptions): Promise<void>;
     (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;

package/dist/types/routeViews.d.ts

@@ -0,0 +1,44 @@
+import { Component } from 'vue';
+import { PrefetchConfig } from './prefetch';
+import { AnyFunction } from './utilities';
+/**
+ * A single view: what to render, how to get its props, and how to prefetch it. `component` is optional
+ * because a route can bind props to the nested RouterView it renders without declaring a component.
+ *
+ * @template TProps - What this view's props getter returns, carried so parent props can be typed from it.
+ */
+export type RouteView<TProps = undefined> = {
+    component?: Component;
+    props?: AnyFunction<TProps>;
+    prefetch?: PrefetchConfig;
+};
+/**
+ * The views for a single route, keyed by view name (the unnamed view under 'default'). Indexed by depth in
+ * `route.views` — parallel to how `route.matches` indexes the matched options, which is where a route's id
+ * comes from at a given depth.
+ */
+export type RouteViews = Record<string, RouteView<unknown>>;
+/**
+ * The props a child sees for a parent's views. A lone unnamed view is given directly rather than under a
+ * 'default' key, matching how the props argument is written. Each view's props are always a promise,
+ * since the parent's props may not have been computed when the child's getter runs.
+ */
+export type ViewsPropsReturnType<TViews> = keyof ViewsWithProps<TViews> extends never ? undefined : keyof ViewsWithProps<TViews> extends 'default' ? ParentViewProps<Extract<ViewsWithProps<TViews>, {
+    default: unknown;
+}>['default']> : {
+    [K in keyof ViewsWithProps<TViews>]: ParentViewProps<ViewsWithProps<TViews>[K]>;
+};
+type ViewsWithProps<TViews> = {
+    [K in keyof TViews as HasViewProps<TViews[K]> extends true ? K : never]: TViews[K];
+};
+/**
+ * A view has props unless its getter is absent, which is carried as props resolving to undefined. Asked
+ * both ways because a getter that only ever throws resolves to never, which is assignable to undefined
+ * without being the absent case.
+ */
+type HasViewProps<TView> = [ViewProps<TView>] extends [undefined] ? [undefined] extends [ViewProps<TView>] ? false : true : true;
+type ViewProps<TView> = TView extends {
+    props?: AnyFunction<infer TProps>;
+} ? TProps : undefined;
+type ParentViewProps<TView> = Promise<Awaited<ViewProps<TView>>>;
+export {};

package/dist/types/routeWithMethods.d.ts

@@ -0,0 +1,16 @@
+import { RouteAddLoader } from './addLoader';
+import { RouteAddView } from './addView';
+import { InternalRouteHooks } from './hooks';
+import { RouteRedirects } from './redirects';
+import { CreatedRouteOptions, Route } from './route';
+import { RouteSetTitle } from './routeTitle';
+import { Url } from './url';
+/**
+ * A route plus every chainable/available method: addView, addLoader, hooks, redirects, and title. The type
+ * level counterpart to `withRouteMethods`.
+ *
+ * Takes the url and matches rather than an assembled route so that adding a view or a loader can rebuild
+ * from them directly. Taking the route would mean re-deriving the url from it on every call, and that
+ * reference is what made chained calls nest one inside the last.
+ */
+export type RouteWithMethods<TUrl extends Url = Url, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = Route<TUrl, TMatches> & RouteAddView<TUrl, TMatches> & RouteAddLoader<TUrl, TMatches> & InternalRouteHooks<Route<TUrl, TMatches>, Route<TUrl, TMatches>['context']> & RouteRedirects<Route<TUrl, TMatches>> & RouteSetTitle<Route<TUrl, TMatches>>;

package/dist/{src/types → types}/routeWithParams.d.ts

@@ -1,5 +1,5 @@
-import { Route, Routes } from '../../types/route';
-import { RoutesName, RoutesMap } from '../../types/routesMap';
-import { UrlParamsWriting } from '../../types/url';
+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>;

package/dist/{src/types → types}/router.d.ts

@@ -1,17 +1,17 @@
 import { App, InjectionKey, Ref } from 'vue';
-import { RouterHistoryMode } from '../../services/createRouterHistory';
-import { RouterRoute } from '../../types/routerRoute';
-import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from '../../types/hooks';
-import { PrefetchConfig } from '../../types/prefetch';
-import { ResolvedRoute } from '../../types/resolved';
-import { Route, Routes } from '../../types/route';
-import { RouterPush } from '../../types/routerPush';
-import { RouterReplace } from '../../types/routerReplace';
-import { RouterResolve, RouterResolveOptions } from '../../types/routerResolve';
-import { RouterReject } from '../../types/routerReject';
-import { RouterPlugin } from '../../types/routerPlugin';
-import { RoutesName } from '../../types/routesMap';
-import { ExtractRejections, ExtractRejectionTypes, Rejections, BuiltInRejectionType } from '../../types/rejection';
+import { RouterHistoryMode } from '../services/createRouterHistory';
+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 { RouterPush } from './routerPush';
+import { RouterReplace } from './routerReplace';
+import { RouterResolve, RouterResolveOptions } from './routerResolve';
+import { RouterReject } from './routerReject';
+import { RouterPlugin } from './routerPlugin';
+import { RoutesName } from './routesMap';
+import { ExtractRejections, ExtractRejectionTypes, Rejections, BuiltInRejectionType } from './rejection';
 /**
  * Options to initialize a {@link Router} instance.
  */

package/dist/{src/types → types}/routerLink.d.ts

@@ -1,8 +1,8 @@
-import { PrefetchConfig } from '../../types/prefetch';
-import { UrlString } from '../../types/urlString';
-import { ResolvedRoute } from '../../types/resolved';
-import { Router } from '../../types/router';
-import { RouterPushOptions } from '../../types/routerPush';
+import { PrefetchConfig } from './prefetch';
+import { UrlString } from './urlString';
+import { ResolvedRoute } from './resolved';
+import { Router } from './router';
+import { RouterPushOptions } from './routerPush';
 export type ToCallback<TRouter extends Router> = (resolve: TRouter['resolve']) => ResolvedRoute | UrlString | undefined;
 export type RouterLinkProps<TRouter extends Router> = RouterPushOptions & {
     /**

package/dist/{src/types → types}/routerPlugin.d.ts

@@ -1,12 +1,12 @@
 import { HookRemove } from './hooks';
 import { Routes } from './route';
 import { Rejections } from './rejection';
-import { Hooks } from '../../models/hooks';
+import { Hooks } from '../models/hooks';
 import { ResolvedRoute } from './resolved';
 import { RouterReject } from './routerReject';
 import { RouterPush } from './routerPush';
 import { RouterReplace } from './routerReplace';
-import { CallbackContextAbort } from '../../services/createRouterCallbackContext';
+import { CallbackContextAbort } from '../services/createRouterCallbackContext';
 import { MaybePromise } from './utilities';
 export type EmptyRouterPlugin = RouterPlugin<[], []>;
 export declare const IS_ROUTER_PLUGIN_SYMBOL: unique symbol;
@@ -49,7 +49,7 @@ type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejecti
 export type PluginErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     to: ResolvedRoute;
     from: ResolvedRoute | null;
-    source: 'props' | 'hook' | 'component';
+    source: 'props' | 'loader' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;

package/dist/{src/types → types}/routerPush.d.ts

@@ -1,11 +1,11 @@
-import { Routes } from '../../types/route';
-import { RoutesName } from '../../types/routesMap';
-import { RouteParamsByKey } from '../../types/routeWithParams';
-import { RouteStateByName } from '../../types/state';
-import { UrlString } from '../../types/urlString';
-import { AllPropertiesAreOptional } from '../../types/utilities';
-import { QuerySource } from '../../types/querySource';
-import { ResolvedRoute } from '../../types/resolved';
+import { Routes } from './route';
+import { RoutesName } from './routesMap';
+import { RouteParamsByKey } from './routeWithParams';
+import { RouteStateByName } from './state';
+import { UrlString } from './urlString';
+import { AllPropertiesAreOptional } from './utilities';
+import { QuerySource } from './querySource';
+import { ResolvedRoute } from './resolved';
 export type RouterPushOptions<TState = unknown> = {
     /**
      * The query string to add to the url.

package/dist/{src/types → types}/routerReject.d.ts

@@ -1,2 +1,2 @@
-import { BuiltInRejectionType, Rejections, RejectionType } from '../../types/rejection';
+import { BuiltInRejectionType, Rejections, RejectionType } from './rejection';
 export type RouterReject<TRejections extends Rejections | undefined> = <TSource extends (RejectionType<TRejections> | BuiltInRejectionType)>(type: TSource) => void;

package/dist/{src/types → types}/routerReplace.d.ts

@@ -1,11 +1,11 @@
-import { Routes } from '../../types/route';
-import { RoutesName } from '../../types/routesMap';
-import { RouteParamsByKey } from '../../types/routeWithParams';
-import { RouteStateByName } from '../../types/state';
-import { UrlString } from '../../types/urlString';
-import { AllPropertiesAreOptional } from '../../types/utilities';
-import { QuerySource } from '../../types/querySource';
-import { ResolvedRoute } from '../../types/resolved';
+import { Routes } from './route';
+import { RoutesName } from './routesMap';
+import { RouteParamsByKey } from './routeWithParams';
+import { RouteStateByName } from './state';
+import { UrlString } from './urlString';
+import { AllPropertiesAreOptional } from './utilities';
+import { QuerySource } from './querySource';
+import { ResolvedRoute } from './resolved';
 export type RouterReplaceOptions<TState = unknown> = {
     query?: QuerySource;
     hash?: string;

package/dist/{src/types → types}/routerResolve.d.ts

@@ -1,10 +1,10 @@
-import { Routes } from '../../types/route';
-import { RoutesName } from '../../types/routesMap';
-import { RouteParamsByKey } from '../../types/routeWithParams';
-import { AllPropertiesAreOptional } from '../../types/utilities';
-import { QuerySource } from '../../types/querySource';
-import { ResolvedRoute } from '../../types/resolved';
-import { RouteStateByName } from '../../types/state';
+import { Routes } from './route';
+import { RoutesName } from './routesMap';
+import { RouteParamsByKey } from './routeWithParams';
+import { AllPropertiesAreOptional } from './utilities';
+import { QuerySource } from './querySource';
+import { ResolvedRoute } from './resolved';
+import { RouteStateByName } from './state';
 export type RouterResolveOptions<TState = unknown> = {
     query?: QuerySource;
     hash?: string;

package/dist/{src/types → types}/routerRoute.d.ts

@@ -1,6 +1,7 @@
-import { RouteUpdate } from '../../types/routeUpdate';
-import { ResolvedRoute } from '../../types/resolved';
-import { QuerySource } from '../../types/querySource';
+import { RouteUpdate } from './routeUpdate';
+import { ResolvedRoute } from './resolved';
+import { RouteDataOf } from './route';
+import { QuerySource } from './querySource';
 export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
     /**
      * Unique identifier for the route, generated by router.
@@ -35,6 +36,11 @@ export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
      * Title of the route.
      */
     readonly title: TRoute['title'];
+    /**
+     * What the route's loaders resolve to, keyed by loader name. A route whose only loader is unnamed
+     * exposes that loader's data here directly.
+     */
+    readonly data: RouteDataOf<TRoute['matches']>;
     params: TRoute['params'];
     state: TRoute['state'];
     get query(): URLSearchParams;

package/dist/{src/types → types}/routesMap.d.ts

@@ -1,5 +1,5 @@
-import { Route, Routes } from '../../types/route';
-import { StringHasValue } from '../../utilities/guards';
+import { Route, Routes } from './route';
+import { StringHasValue } from '../utilities/guards';
 type IsRouteUnnamed<T extends Route> = StringHasValue<T['name']> extends true ? false : true;
 type AsNamedRoute<T extends Route> = IsRouteUnnamed<T> extends true ? never : T;
 export type RoutesMap<TRoutes extends Routes = []> = {

package/dist/{src/types → types}/state.d.ts

@@ -1,9 +1,9 @@
-import { ExtractParamName, ExtractParamType } from '../../types/params';
-import { Param } from '../../types/paramTypes';
-import { Routes } from '../../types/route';
-import { RouteGetByKey } from '../../types/routeWithParams';
-import { MakeOptional } from '../../utilities/makeOptional';
-import { Identity } from '../../types/utilities';
+import { ExtractParamName, ExtractParamType } from './params';
+import { Param } from './paramTypes';
+import { Routes } from './route';
+import { RouteGetByKey } from './routeWithParams';
+import { MakeOptional } from '../utilities/makeOptional';
+import { Identity } from './utilities';
 export type ToState<TState extends Record<string, Param> | undefined> = TState extends undefined ? Record<string, Param> : unknown extends TState ? {} : TState;
 export type ExtractRouteStateParamsAsOptional<TParams extends Record<string, Param>> = {
     [K in keyof TParams]: ExtractParamType<TParams[K]> | undefined;

package/dist/{src/types → types}/url.d.ts

@@ -1,9 +1,9 @@
-import { OptionalUrlParam, UrlQueryPart, ToUrlQueryPart, RequiredUrlParam, ToUrlPart, UrlParams, UrlPart } from '../../services/withParams';
-import { ExtractParamType } from '../../types/params';
-import { AllPropertiesAreOptional, Identity } from '../../types/utilities';
-import { UrlString } from '../../types/urlString';
-import { ParamGetSet } from '../../types/paramTypes';
-import { MakeOptional } from '../../utilities/makeOptional';
+import { OptionalUrlParam, UrlQueryPart, ToUrlQueryPart, RequiredUrlParam, ToUrlPart, UrlParams, UrlPart } from '../services/withParams';
+import { ExtractParamType } from './params';
+import { AllPropertiesAreOptional, Identity } from './utilities';
+import { UrlString } from './urlString';
+import { ParamGetSet } from './paramTypes';
+import { MakeOptional } from '../utilities/makeOptional';
 export declare const IS_URL_SYMBOL: unique symbol;
 export type UrlInternal = {
     [IS_URL_SYMBOL]: true;

package/dist/{src/types → types}/useLink.d.ts

@@ -1,9 +1,9 @@
 import { ComputedRef, Ref } from 'vue';
-import { PrefetchConfig } from '../../types/prefetch';
-import { ResolvedRoute } from '../../types/resolved';
-import { RouterPushOptions } from '../../types/routerPush';
-import { RouterReplaceOptions } from '../../types/routerReplace';
-import { UrlString } from '../../types/urlString';
+import { PrefetchConfig } from './prefetch';
+import { ResolvedRoute } from './resolved';
+import { RouterPushOptions } from './routerPush';
+import { RouterReplaceOptions } from './routerReplace';
+import { UrlString } from './urlString';
 export type UseLink = {
     /**
      * A template ref to bind to the dom for automatic prefetching

package/dist/{src/types → types}/utilities.d.ts

@@ -4,6 +4,7 @@ export type Identity<T> = T extends object ? {} & {
 type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
 export type LastInArray<T, TFallback = never> = T extends [...any[], infer Last] ? Last : TFallback;
 export type MaybePromise<T> = T | Promise<T>;
+export type AnyFunction<TReturn = any> = (...args: any[]) => TReturn;
 type OnlyRequiredProperties<T> = {
     [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
 };

package/dist/{src/utilities → utilities}/checkDuplicateNames.d.ts

@@ -1,2 +1,2 @@
-import { Routes } from '../../types/route';
+import { Routes } from '../types/route';
 export declare function checkDuplicateNames(routes: Routes): void;

package/dist/utilities/checkDuplicateNames.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/checkDuplicateParams.spec.d.ts

@@ -0,0 +1 @@
+export {};