@kitbag/router 0.20.6 → 0.20.8

package/dist/types/props.d.ts

@@ -0,0 +1,23 @@
+import { CallbackContext } from '../services/createCallbackContext';
+import { PropsGetter } from './createRouteOptions';
+import { Route } from './route';
+/**
+ * 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 PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
+    name: string;
+    props: unknown;
+} : TParent extends Route ? {
+    name: TParent['name'];
+    props: GetParentPropsReturnType<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;
+export {};

package/dist/types/querySource.d.ts

@@ -0,0 +1 @@
+export type QuerySource = ConstructorParameters<typeof URLSearchParams>[0];

package/dist/types/register.d.ts

@@ -0,0 +1,68 @@
+import { BuiltInRejectionType } from '../services/createRouterReject';
+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.
+ *
+ * @example
+ * ```ts
+ * declare module '@kitbag/router' {
+ *   interface Register {
+ *     router: typeof router
+ *     routeMeta: { public?: boolean }
+ *   }
+ * }
+ * ```
+ */
+export interface Register {
+}
+/**
+ * Represents the Router property within {@link Register}
+ */
+export type RegisteredRouter<T = Register> = T extends {
+    router: infer TRouter;
+} ? 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>;
+} ? keyof TOptions['rejections'] | BuiltInRejectionType : BuiltInRejectionType;
+/**
+ * Represents additional metadata associated with a route, customizable via declaration merging.
+ */
+export type RouteMeta<T = Register> = T extends {
+    routeMeta: infer RouteMeta extends Record<string, unknown>;
+} ? 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/register.spec.d.ts

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

package/dist/types/resolved.d.ts

@@ -0,0 +1,47 @@
+import { ExtractRouteParamTypesReading } from './params';
+import { Route } from './route';
+import { ExtractRouteStateParamsAsOptional } from './state';
+import { Url } from './url';
+/**
+ * Represents a route that the router has matched to current browser location.
+ * @template TRoute - Underlying Route that has been resolved.
+ */
+export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
+    /**
+     * Unique identifier for the route, generated by router.
+    */
+    id: TRoute['id'];
+    /**
+     * The specific route properties that were matched in the current route.
+    */
+    matched: TRoute['matched'];
+    /**
+     * 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: TRoute['matches'];
+    /**
+     * Unique identifier for the route. Name is used for routing and for matching.
+    */
+    name: TRoute['name'];
+    /**
+     * Accessor for query string values from user in the current browser location.
+    */
+    query: URLSearchParams;
+    /**
+     * Hash value of the route.
+    */
+    hash: string;
+    /**
+     * Key value pair for route params, values will be the user provided value from current browser location.
+    */
+    params: ExtractRouteParamTypesReading<TRoute>;
+    /**
+     * Type for additional data intended to be stored in history state.
+     */
+    state: ExtractRouteStateParamsAsOptional<TRoute['state']>;
+    /**
+     * String value of the resolved URL.
+     */
+    href: Url;
+}>;

package/dist/types/resolved.spec-d.d.ts

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

package/dist/types/route.d.ts

@@ -0,0 +1,76 @@
+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';
+/**
+ * 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`. The only change is normalizing meta to always default to an empty object.
+ */
+export type CreatedRouteOptions = Omit<CreateRouteOptions, 'props'> & WithHooks & {
+    id: string;
+    props?: unknown;
+};
+/**
+ * Represents the structure of a route within the application. Return value of `createRoute`
+ * @template TName - Represents the unique name identifying the route, typically a string.
+ * @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[]> = {
+    /**
+     * Unique identifier for the route, generated by router.
+    */
+    id: string;
+    /**
+     * The specific route properties that were matched in the current route.
+    */
+    matched: LastInArray<TMatches, CreatedRouteOptions>;
+    /**
+     * 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: TName;
+    /**
+     * Represents the host for this route. Used for external routes.
+    */
+    host: THost;
+    /**
+     * Represents the structured path of the route, including path params.
+    */
+    path: TPath;
+    /**
+     * Represents the structured query of the route, including query params.
+    */
+    query: TQuery;
+    /**
+     * Represents the hash of the route.
+     */
+    hash: THash;
+    /**
+     * Represents additional metadata associated with a route, combined with any parents.
+    */
+    meta: TMeta;
+    /**
+     * Represents the schema of the route state, combined with any parents.
+    */
+    state: TState;
+    /**
+     * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
+    */
+    prefetch?: PrefetchConfig;
+    /**
+    * A value that represents how many parents a route has. Used for route matching
+    * @internal
+    */
+    depth: number;
+};

package/dist/types/route.spec-d.d.ts

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

package/dist/types/routeMatchRule.d.ts

@@ -0,0 +1,2 @@
+import { Route } from './route';
+export type RouteMatchRule = (route: Route, url: string) => boolean;

package/dist/types/routeUpdate.d.ts

@@ -0,0 +1,9 @@
+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>;
+} : {
+    <TParamName extends keyof TRoute['params']>(paramName: TParamName, paramValue: TRoute['params'][TParamName], options?: RouterPushOptions): Promise<void>;
+    (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
+};

package/dist/types/routeWithParams.d.ts

@@ -0,0 +1,5 @@
+import { ExtractRouteParamTypesWriting } from './params';
+import { Route, Routes } from './route';
+import { RoutesName, RoutesMap } from './routesMap';
+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 ? ExtractRouteParamTypesWriting<RouteGetByKey<TRoutes, TKey>> : Record<string, unknown>;

package/dist/types/routeWithParams.spec-d.d.ts

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

package/dist/types/router.d.ts

@@ -0,0 +1,186 @@
+import { App, Component, InjectionKey, Ref } from 'vue';
+import { RouterHistoryMode } from '../services/createRouterHistory';
+import { RouterRoute } from './routerRoute';
+import { RouteHookRemove, WithHooks } 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 { KeysOfUnion, MaybePromise } from './utilities';
+import { RoutesName } from './routesMap';
+import { AfterRouteHookResponse, BeforeRouteHookResponse } from '../main';
+import { CallbackContextAbort } from '../services/createCallbackContext';
+/**
+ * Options to initialize a {@link Router} instance.
+ */
+export type RouterOptions = WithHooks & {
+    /**
+     * Initial URL for the router to use. Required if using Node environment. Defaults to window.location when using browser.
+     *
+     * @default window.location.toString()
+     */
+    initialUrl?: string;
+    /**
+     * Specifies the history mode for the router, such as "browser", "memory", or "hash".
+     *
+     * @default "auto"
+     */
+    historyMode?: RouterHistoryMode;
+    /**
+     * Base path to be prepended to any URL. Can be used for Vue applications that run in nested folder for domain.
+     * For example having `base` of `/foo` would assume all routes should start with `your.domain.com/foo`.
+     */
+    base?: string;
+    /**
+     * Determines what assets are prefetched when router-link is rendered for a specific route
+     */
+    prefetch?: PrefetchConfig;
+    /**
+     * Components assigned to each type of rejection your router supports.
+     */
+    rejections?: Partial<Record<string, Component>>;
+    /**
+     * When false, createRouterAssets must be used for component and hooks. Assets exported by the library
+     * will not work with the created router instance.
+     *
+     * @default true
+     */
+    isGlobalRouter?: boolean;
+};
+export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions = any, TPlugin extends RouterPlugin = any> = {
+    /**
+     * Installs the router into a Vue application instance.
+     * @param app The Vue application instance to install the router into
+     */
+    install: (app: App) => void;
+    /**
+     * Manages the current route state.
+    */
+    route: RouterRouteUnion<TRoutes> | RouterRouteUnion<TPlugin['routes']>;
+    /**
+     * Creates a ResolvedRoute record for a given route name and params.
+     */
+    resolve: RouterResolve<TRoutes | TPlugin['routes']>;
+    /**
+     * Creates a ResolvedRoute record for a given URL.
+     */
+    find: (url: string, options?: RouterResolveOptions) => ResolvedRoute | undefined;
+    /**
+     * Navigates to a specified path or route object in the history stack, adding a new entry.
+     */
+    push: RouterPush<TRoutes | TPlugin['routes']>;
+    /**
+     * Replaces the current entry in the history stack with a new one.
+     */
+    replace: RouterReplace<TRoutes | TPlugin['routes']>;
+    /**
+     * Handles route rejection based on a specified rejection type.
+     */
+    reject: RouterReject<keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    /**
+     * Forces the router to re-evaluate the current route.
+     */
+    refresh: () => void;
+    /**
+     * Navigates to the previous entry in the browser's history stack.
+     */
+    back: () => void;
+    /**
+     * Navigates to the next entry in the browser's history stack.
+     */
+    forward: () => void;
+    /**
+     * Moves the current history entry to a specific point in the history stack.
+     */
+    go: (delta: number) => void;
+    /**
+     * Registers a hook to be called before a route is entered.
+     */
+    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'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    /**
+     * Registers a hook to be called before a route is updated.
+     */
+    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'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    /**
+     * Registers a hook to be called after a route is left.
+     */
+    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'], keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
+    /**
+    * Given a URL, returns true if host does not match host stored on router instance
+    */
+    isExternal: (url: string) => boolean;
+    /**
+     * Determines what assets are prefetched.
+     */
+    prefetch?: PrefetchConfig;
+    /**
+     * Initializes the router based on the initial route. Automatically called when the router is installed. Calling this more than once has no effect.
+     */
+    start: () => Promise<void>;
+    /**
+     * Returns true if the router has been started.
+     */
+    started: Ref<boolean>;
+    /**
+     * Stops the router and teardown any listeners.
+     */
+    stop: () => void;
+    /**
+     * Returns the key of the router.
+     *
+     * @private
+     */
+    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>;
+/**
+ * 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 RouterRouteName<TRouter extends Router> = TRouter extends Router<infer TRoutes extends Routes> ? RoutesName<TRoutes> : RoutesName<Route[]>;
+export {};

package/dist/types/routerLink.d.ts

@@ -0,0 +1,16 @@
+import { PrefetchConfig } from './prefetch';
+import { Url } from './url';
+import { ResolvedRoute } from './resolved';
+import { Router } from './router';
+import { RouterPushOptions } from './routerPush';
+export type ToCallback<TRouter extends Router> = (resolve: TRouter['resolve']) => ResolvedRoute | Url | undefined;
+export type RouterLinkProps<TRouter extends Router> = RouterPushOptions & {
+    /**
+     * The url string to navigate to or a callback that returns a url string
+     */
+    to: Url | ResolvedRoute | ToCallback<TRouter>;
+    /**
+     * Determines what assets are prefetched when router-link is rendered for this route. Overrides route level prefetch.
+     */
+    prefetch?: PrefetchConfig;
+};

package/dist/types/routerPlugin.d.ts

@@ -0,0 +1,18 @@
+import { Component } from 'vue';
+import { BeforeRouteHook, AfterRouteHook } 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;
+    onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
+    onAfterRouteEnter?: MaybeArray<AfterRouteHook>;
+    onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
+    onAfterRouteUpdate?: MaybeArray<AfterRouteHook>;
+    onBeforeRouteLeave?: MaybeArray<BeforeRouteHook>;
+    onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
+};

package/dist/types/routerPush.d.ts

@@ -0,0 +1,33 @@
+import { Routes } from './route';
+import { RoutesName } from './routesMap';
+import { RouteParamsByKey } from './routeWithParams';
+import { RouteStateByName } from './state';
+import { Url } from './url';
+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.
+     */
+    query?: QuerySource;
+    /**
+     * The hash to append to the url.
+     */
+    hash?: string;
+    /**
+     * Whether to replace the current history entry.
+     */
+    replace?: boolean;
+    /**
+     * State values to pass to the route.
+     */
+    state?: Partial<TState>;
+};
+type RouterPushArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>];
+export type RouterPush<TRoutes extends Routes = any> = {
+    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterPushArgs<TRoutes, TSource>): Promise<void>;
+    (route: ResolvedRoute, options?: RouterPushOptions): Promise<void>;
+    (url: Url, options?: RouterPushOptions): Promise<void>;
+};
+export {};

package/dist/types/routerReject.d.ts

@@ -0,0 +1,3 @@
+import { BuiltInRejectionType } from '../services/createRouterReject';
+import { AsString } from './utilities';
+export type RouterReject<TRejectionType extends PropertyKey> = (type: AsString<TRejectionType> | BuiltInRejectionType) => void;

package/dist/types/routerReplace.d.ts

@@ -0,0 +1,20 @@
+import { Routes } from './route';
+import { RoutesName } from './routesMap';
+import { RouteParamsByKey } from './routeWithParams';
+import { RouteStateByName } from './state';
+import { Url } from './url';
+import { AllPropertiesAreOptional } from './utilities';
+import { QuerySource } from './querySource';
+import { ResolvedRoute } from './resolved';
+export type RouterReplaceOptions<TState = unknown> = {
+    query?: QuerySource;
+    hash?: string;
+    state?: Partial<TState>;
+};
+type RouterReplaceArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterReplaceOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterReplaceOptions<RouteStateByName<TRoutes, TSource>>];
+export type RouterReplace<TRoutes extends Routes> = {
+    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
+    (route: ResolvedRoute, options?: RouterReplaceOptions): Promise<void>;
+    (url: Url, options?: RouterReplaceOptions): Promise<void>;
+};
+export {};

package/dist/types/routerResolve.d.ts

@@ -0,0 +1,15 @@
+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;
+    state?: Partial<TState>;
+};
+type RouterResolveArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterResolveOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterResolveOptions<RouteStateByName<TRoutes, TSource>>];
+export type RouterResolve<TRoutes extends Routes> = <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterResolveArgs<TRoutes, TSource>) => ResolvedRoute;
+export {};

package/dist/types/routerRoute.d.ts

@@ -0,0 +1,16 @@
+import { RouteUpdate } from './routeUpdate';
+import { ResolvedRoute } from './resolved';
+import { QuerySource } from './querySource';
+export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
+    readonly id: TRoute['id'];
+    readonly name: TRoute['name'];
+    readonly matched: TRoute['matched'];
+    readonly matches: TRoute['matches'];
+    readonly hash: TRoute['hash'];
+    readonly update: RouteUpdate<TRoute>;
+    readonly href: TRoute['href'];
+    params: TRoute['params'];
+    state: TRoute['state'];
+    get query(): URLSearchParams;
+    set query(value: QuerySource);
+};

package/dist/types/routesMap.d.ts

@@ -0,0 +1,9 @@
+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 = []> = {
+    [K in TRoutes[number] as AsNamedRoute<K>['name']]: AsNamedRoute<K>;
+};
+export type RoutesName<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
+export {};

package/dist/types/routesMap.spec-ts.d.ts

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

package/dist/types/state.d.ts

@@ -0,0 +1,18 @@
+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;
+};
+export type RouteStateByName<TRoutes extends Routes, TName extends string> = ExtractStateParams<RouteGetByKey<TRoutes, TName>>;
+type ExtractStateParams<TRoute> = TRoute extends {
+    state: infer TState extends Record<string, Param>;
+} ? ExtractParamTypes<TState> : Record<string, unknown>;
+type ExtractParamTypes<TParams extends Record<string, Param>> = Identity<MakeOptional<{
+    [K in keyof TParams as ExtractParamName<K>]: ExtractParamType<TParams[K]>;
+}>>;
+export {};

package/dist/types/url.d.ts

@@ -0,0 +1,23 @@
+import { QuerySource } from './querySource';
+export type Url = `http://${string}` | `https://${string}` | `/${string}`;
+export type UrlParts = {
+    protocol?: string;
+    host?: string;
+    pathname: string;
+    searchParams: QuerySource;
+    search: string;
+    hash: string;
+};
+/**
+ * A type guard for determining if a value is a valid URL.
+ * @param value - The value to check.
+ * @returns `true` if the value is a valid URL, otherwise `false`.
+ * @group Type Guards
+ */
+export declare function isUrl(value: unknown): value is Url;
+/**
+ * Converts a string to a valid URL.
+ * @param value - The string to convert.
+ * @returns The valid URL.
+ */
+export declare function asUrl(value: string): Url;