@kitbag/router 0.20.6 → 0.20.8

package/dist/services/combinePath.d.ts

@@ -0,0 +1,12 @@
+import { ToWithParams, WithParams } from './withParams';
+import { Param } from '../types/paramTypes';
+type CombinePathString<TParent extends string, TChild extends string> = `${TParent}${TChild}`;
+export type CombinePath<TParent extends WithParams, TChild extends WithParams> = ToWithParams<TParent> extends {
+    value: infer TParentPath extends string;
+    params: infer TParentParams extends Record<string, unknown>;
+} ? ToWithParams<TChild> extends {
+    value: infer TChildPath extends string;
+    params: infer TChildParams extends Record<string, unknown>;
+} ? TParentParams & TChildParams extends Record<string, Param | undefined> ? WithParams<CombinePathString<TParentPath, TChildPath>, TParentParams & TChildParams> : WithParams<CombinePathString<TParentPath, TChildPath>, {}> : WithParams<'', {}> : WithParams<'', {}>;
+export declare function combinePath<TParentPath extends WithParams, TChildPath extends WithParams>(parentPath: TParentPath, childPath: TChildPath): CombinePath<TParentPath, TChildPath>;
+export {};

package/dist/services/combinePath.spec-d.d.ts

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

package/dist/services/combinePath.spec.d.ts

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

package/dist/services/combineQuery.d.ts

@@ -0,0 +1,13 @@
+import { StringHasValue } from '../utilities/guards';
+import { ToWithParams, WithParams } from './withParams';
+import { Param } from '../types/paramTypes';
+type CombineQueryString<TParent extends string | undefined, TChild extends string | undefined> = StringHasValue<TParent> extends true ? StringHasValue<TChild> extends true ? `${TParent}&${TChild}` : TParent : TChild;
+export type CombineQuery<TParent extends WithParams, TChild extends WithParams> = ToWithParams<TParent> extends {
+    value: infer TParentQuery extends string;
+    params: infer TParentParams extends Record<string, unknown>;
+} ? ToWithParams<TChild> extends {
+    value: infer TChildQuery extends string;
+    params: infer TChildParams extends Record<string, unknown>;
+} ? TParentParams & TChildParams extends Record<string, Param | undefined> ? WithParams<CombineQueryString<TParentQuery, TChildQuery>, TParentParams & TChildParams> : WithParams<CombineQueryString<TParentQuery, TChildQuery>, {}> : WithParams<'', {}> : WithParams<'', {}>;
+export declare function combineQuery<TParentQuery extends WithParams, TChildQuery extends WithParams>(parentQuery: TParentQuery, childQuery: TChildQuery): CombineQuery<TParentQuery, TChildQuery>;
+export {};

package/dist/services/combineQuery.spec.d.ts

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

package/dist/services/combineState.d.ts

@@ -0,0 +1,3 @@
+import { Param } from '../types/paramTypes';
+export type CombineState<TParent extends Record<string, Param>, TChild extends Record<string, Param>> = TParent & TChild;
+export declare function combineState<TParentState extends Record<string, Param>, TChildState extends Record<string, Param>>(parentState: TParentState, childState: TChildState): CombineState<TParentState, TChildState>;

package/dist/services/combineState.spec.d.ts

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

package/dist/services/component.browser.spec.d.ts

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

package/dist/services/component.d.ts

@@ -0,0 +1,12 @@
+import { AsyncComponentLoader, Component, FunctionalComponent, InjectionKey } from 'vue';
+import { CreatedRouteOptions } from '../types/route';
+import { Router } from '../types/router';
+type Constructor = new (...args: any) => any;
+export type ComponentProps<TComponent extends Component> = TComponent extends Constructor ? InstanceType<TComponent>['$props'] : TComponent extends AsyncComponentLoader<infer T extends Component> ? ComponentProps<T> : TComponent extends FunctionalComponent<infer T> ? T : {};
+type CreateComponentWrapperConfig = {
+    match: CreatedRouteOptions;
+    name: string;
+    component: Component;
+};
+export declare function createComponentPropsWrapper(routerKey: InjectionKey<Router>, { match, name, component }: CreateComponentWrapperConfig): Component;
+export {};

package/dist/services/createCallbackContext.d.ts

@@ -0,0 +1,44 @@
+import { RegisteredRejectionType, RegisteredRouterPush, RegisteredRouterReject, RegisteredRouterReplace } from '../types/register';
+/**
+ * Defines the structure of a successful callback response.
+ */
+export type CallbackSuccessResponse = {
+    status: 'SUCCESS';
+};
+/**
+ * Defines the structure of an aborted callback response.
+ */
+export type CallbackAbortResponse = {
+    status: 'ABORT';
+};
+/**
+ * Defines the structure of a callback response that results in a push to a new route.
+ */
+export type CallbackPushResponse = {
+    status: 'PUSH';
+    to: Parameters<RegisteredRouterPush>;
+};
+/**
+ * Defines the structure of a callback response that results in the rejection of a route transition.
+ */
+export type CallbackRejectResponse = {
+    status: 'REJECT';
+    type: RegisteredRejectionType;
+};
+/**
+ * A function that can be called to abort a routing operation.
+ */
+export type CallbackContextAbort = () => void;
+/**
+ * @deprecated Use `RouterCallbackContext` instead.
+ */
+export type CallbackContext = {
+    reject: RegisteredRouterReject;
+    push: RegisteredRouterPush;
+    replace: RegisteredRouterReplace;
+    abort: CallbackContextAbort;
+};
+/**
+ * @deprecated Use `createRouterCallbackContext` instead.
+ */
+export declare function createCallbackContext(): CallbackContext;

package/dist/services/createComponentHooks.d.ts

@@ -0,0 +1,11 @@
+import { InjectionKey } from 'vue';
+import { AddRouterAfterRouteHook, AddRouterBeforeRouteHook, Router, RouterRejections, RouterRoutes } from '../types/router';
+import { Routes } from '../types/route';
+type ComponentHooks<TRoutes extends Routes, TRejections extends PropertyKey> = {
+    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes, TRejections>;
+    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes, TRejections>;
+    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes, TRejections>;
+    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes, TRejections>;
+};
+export declare function createComponentHooks<TRouter extends Router>(routerKey: InjectionKey<TRouter>): ComponentHooks<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+export {};

package/dist/services/createComponentsStore.d.ts

@@ -0,0 +1,7 @@
+import { Component, InjectionKey } from 'vue';
+import { CreatedRouteOptions } from '../types/route';
+import { Router } from '../types/router';
+export type ComponentsStore = {
+    getRouteComponents: (match: CreatedRouteOptions) => Record<string, Component>;
+};
+export declare function createComponentsStore<TRouter extends Router>(routerKey: InjectionKey<TRouter>): ComponentsStore;

package/dist/services/createCurrentRoute.d.ts

@@ -0,0 +1,13 @@
+import { InjectionKey } from 'vue';
+import { Router, RouterRouteUnion } from '../types/router';
+import { ResolvedRoute } from '../types/resolved';
+import { Routes } from '../types/route';
+import { RouterPush } from '../types/routerPush';
+type ResolvedRouteUpdate = (route: ResolvedRoute) => void;
+type CurrentRouteContext<TRoutes extends Routes = Routes> = {
+    currentRoute: ResolvedRoute;
+    routerRoute: RouterRouteUnion<TRoutes>;
+    updateRoute: ResolvedRouteUpdate;
+};
+export declare function createCurrentRoute<TRoutes extends Routes>(routerKey: InjectionKey<Router>, fallbackRoute: ResolvedRoute, push: RouterPush): CurrentRouteContext<TRoutes>;
+export {};

package/dist/services/createExternalRoute.d.ts

@@ -0,0 +1,3 @@
+import { CreateRouteOptions, ToRoute, WithHost, WithoutHost, WithoutParent, WithParent } from '../types/createRouteOptions';
+export declare function createExternalRoute<const TOptions extends CreateRouteOptions & WithHost & WithoutParent>(options: TOptions): ToRoute<TOptions, undefined>;
+export declare function createExternalRoute<const TOptions extends CreateRouteOptions & WithoutHost & WithParent>(options: TOptions): ToRoute<TOptions, undefined>;

package/dist/services/createExternalRoute.spec.d.ts

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

package/dist/services/createIsExternal.d.ts

@@ -0,0 +1 @@
+export declare function createIsExternal(host: string | undefined): (url: string) => boolean;

package/dist/services/createIsExternal.spec.d.ts

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

package/dist/services/createParam.d.ts

@@ -0,0 +1,6 @@
+import { ParamWithDefault } from './withDefault';
+import { ExtractParamType } from '../types/params';
+import { Param, ParamGetSet } from '../types/paramTypes';
+export declare function createParam<TParam extends ParamWithDefault>(param: TParam): TParam;
+export declare function createParam<TParam extends Param>(param: TParam): ParamGetSet<ExtractParamType<TParam>>;
+export declare function createParam<TParam extends Param>(param: TParam, defaultValue: NoInfer<ExtractParamType<TParam>>): ParamWithDefault<TParam>;

package/dist/services/createPropStore.d.ts

@@ -0,0 +1,13 @@
+import { PrefetchConfigs, PrefetchStrategy } from '../types/prefetch';
+import { ResolvedRoute } from '../types/resolved';
+import { CallbackPushResponse, CallbackRejectResponse, CallbackSuccessResponse } from './createCallbackContext';
+import { HasVueAppStore } from './createVueAppStore';
+type SetPropsResponse = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse;
+export type PropStore = HasVueAppStore & {
+    getPrefetchProps: (strategy: PrefetchStrategy, route: ResolvedRoute, configs: PrefetchConfigs) => Record<string, unknown>;
+    setPrefetchProps: (props: Record<string, unknown>) => void;
+    setProps: (route: ResolvedRoute) => Promise<SetPropsResponse>;
+    getProps: (id: string, name: string, route: ResolvedRoute) => unknown;
+};
+export declare function createPropStore(): PropStore;
+export {};

package/dist/services/createResolvedRoute.d.ts

@@ -0,0 +1,4 @@
+import { ResolvedRoute } from '../types/resolved';
+import { Route } from '../types/route';
+import { RouterResolveOptions } from '../types/routerResolve';
+export declare function createResolvedRoute(route: Route, params?: Record<string, unknown>, options?: RouterResolveOptions): ResolvedRoute;

package/dist/services/createResolvedRouteForUrl.browser.spec.d.ts

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

package/dist/services/createResolvedRouteForUrl.d.ts

@@ -0,0 +1,3 @@
+import { ResolvedRoute } from '../types/resolved';
+import { Routes } from '../types/route';
+export declare function createResolvedRouteForUrl(routes: Routes, url: string, state?: Partial<unknown>): ResolvedRoute | undefined;

package/dist/services/createResolvedRouteQuery.d.ts

@@ -0,0 +1,5 @@
+import { QuerySource } from '../types/querySource';
+/**
+ * Creates a dumb wrapper around URLSearchParams because URLSearchParams cannot be correctly be proxied to support writing params to the RouterRoute
+ */
+export declare function createResolvedRouteQuery(query?: QuerySource): URLSearchParams;

package/dist/services/createRoute.d.ts

@@ -0,0 +1,4 @@
+import { CreateRouteOptions, PropsGetter, CreateRouteProps, ToRoute } from '../types/createRouteOptions';
+type CreateRouteWithProps<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions>> = CreateRouteProps<TOptions> extends PropsGetter<TOptions> ? Partial<ReturnType<CreateRouteProps<TOptions>>> extends ReturnType<CreateRouteProps<TOptions>> ? [props?: TProps] : [props: TProps] : Partial<CreateRouteProps<TOptions>> extends CreateRouteProps<TOptions> ? [props?: TProps] : [props: TProps];
+export declare function createRoute<const TOptions extends CreateRouteOptions, const TProps extends CreateRouteProps<TOptions>>(options: TOptions, ...args: CreateRouteWithProps<TOptions, TProps>): ToRoute<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>;
+export {};

package/dist/services/createRoute.spec-d.d.ts

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

package/dist/services/createRoute.spec.d.ts

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

package/dist/services/createRouteId.d.ts

@@ -0,0 +1 @@
+export declare const createRouteId: () => string;

package/dist/services/createRouter.browser.spec.d.ts

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

package/dist/services/createRouter.d.ts

@@ -0,0 +1,28 @@
+import { Routes } from '../types/route';
+import { Router, RouterOptions } from '../types/router';
+import { EmptyRouterPlugin, RouterPlugin } from '../types/routerPlugin';
+/**
+ * Creates a router instance for a Vue application, equipped with methods for route handling, lifecycle hooks, and state management.
+ *
+ * @param routes - {@link Routes} An array of route definitions specifying the configuration of routes in the application.
+ * Use createRoute method to create the route definitions.
+ * @param options - {@link RouterOptions} for the router, including history mode and initial URL settings.
+ * @returns Router instance
+ *
+ * @example
+ * ```ts
+ * import { createRoute, createRouter } from '@kitbag/router'
+ *
+ * const Home = { template: '<div>Home</div>' }
+ * const About = { template: '<div>About</div>' }
+ *
+ * export const routes = [
+ *   createRoute({ name: 'home', path: '/', component: Home }),
+ *   createRoute({ name: 'path', path: '/about', component: About }),
+ * ] as const
+ *
+ * const router = createRouter(routes)
+ * ```
+ */
+export declare function createRouter<const TRoutes extends Routes, const TOptions extends RouterOptions, const TPlugin extends RouterPlugin = EmptyRouterPlugin>(routes: TRoutes, options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>;
+export declare function createRouter<const TRoutes extends Routes, const TOptions extends RouterOptions, const TPlugin extends RouterPlugin = EmptyRouterPlugin>(routes: TRoutes[], options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>;

package/dist/services/createRouter.spec-d.d.ts

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

package/dist/services/createRouter.spec.d.ts

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

package/dist/services/createRouterAssets.d.ts

@@ -0,0 +1,118 @@
+import { Router, RouterRoutes, AddRouterBeforeRouteHook, AddRouterAfterRouteHook, RouterRejections } from '../types/router';
+import { InjectionKey } from 'vue';
+import { createRouterView } from '../components/routerView';
+import { createRouterLink } from '../components/routerLink';
+import { createUseRoute } from '../compositions/useRoute';
+import { createUseRouter } from '../compositions/useRouter';
+import { createUseQueryValue } from '../compositions/useQueryValue';
+import { createUseLink } from '../compositions/useLink';
+import { createIsRoute } from '../guards/routes';
+type RouterAssets<TRouter extends Router> = {
+    /**
+     * Registers a hook that is called before a route is left. Must be called from setup.
+     * This is useful for performing actions or cleanups before navigating away from a route component.
+     *
+     * @param BeforeRouteHook - The hook callback function
+     * @returns {RouteHookRemove} A function that removes the added hook.
+     * @group Hooks
+     */
+    onBeforeRouteLeave: AddRouterBeforeRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    /**
+     * Registers a hook that is called before a route is updated. Must be called from setup.
+     * This is particularly useful for handling changes in route parameters or query while staying within the same component.
+     *
+     * @param BeforeRouteHook - The hook callback function
+     * @returns {RouteHookRemove} A function that removes the added hook.
+     * @group Hooks
+     */
+    onBeforeRouteUpdate: AddRouterBeforeRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    /**
+     * Registers a hook that is called after a route has been left. Must be called during setup.
+     * This can be used for cleanup actions after the component is no longer active, ensuring proper resource management.
+     *
+     * @param AfterRouteHook - The hook callback function
+     * @returns {RouteHookRemove} A function that removes the added hook.
+     * @group Hooks
+     */
+    onAfterRouteLeave: AddRouterAfterRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    /**
+     * Registers a hook that is called after a route has been updated. Must be called during setup.
+     * This is ideal for responding to updates within the same route, such as parameter changes, without full component reloads.
+     *
+     * @param AfterRouteHook - The hook callback function
+     * @returns {RouteHookRemove} A function that removes the added hook.
+     * @group Hooks
+     */
+    onAfterRouteUpdate: AddRouterAfterRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    /**
+     * A guard to verify if a route or unknown value matches a given route name.
+     *
+     * @param routeName - The name of the route to check against the current route.
+     * @returns True if the current route matches the given route name, false otherwise.
+     * @group Guards
+     */
+    isRoute: ReturnType<typeof createIsRoute<TRouter>>;
+    /**
+     * A component to render the current route's component.
+     *
+     * @param props - The props to pass to the router view component.
+     * @returns The router view component.
+     * @group Components
+     */
+    RouterView: ReturnType<typeof createRouterView<TRouter>>;
+    /**
+     * A component to render a link to a route or any url.
+     *
+     * @param props - The props to pass to the router link component.
+     * @returns The router link component.
+     * @group Components
+     */
+    RouterLink: ReturnType<typeof createRouterLink<TRouter>>;
+    /**
+     * A composition to access the current route or verify a specific route name within a Vue component.
+     * This function provides two overloads:
+     * 1. When called without arguments, it returns the current route from the router without types.
+     * 2. When called with a route name, it checks if the current active route includes the specified route name.
+     *
+     * The function also sets up a reactive watcher on the route object from the router to continually check the validity of the route name
+     * if provided, throwing an error if the validation fails at any point during the component's lifecycle.
+     *
+     * @template TRouteName - A string type that should match route name of RouterRouteName<TRouter>, ensuring the route name exists.
+     * @param routeName - Optional. The name of the route to validate against the current active routes.
+     * @returns The current router route. If a route name is provided, it validates the route name first.
+     * @throws {UseRouteInvalidError} Throws an error if the provided route name is not valid or does not match the current route.
+     * @group Compositions
+     */
+    useRoute: ReturnType<typeof createUseRoute<TRouter>>;
+    /**
+     * A composition to access the installed router instance within a Vue component.
+     *
+     * @returns The installed router instance.
+     * @throws {RouterNotInstalledError} Throws an error if the router has not been installed,
+     *         ensuring the component does not operate without routing functionality.
+     * @group Compositions
+     */
+    useRouter: ReturnType<typeof createUseRouter<TRouter>>;
+    /**
+     * A composition to access a specific query value from the current route.
+     *
+     * @returns The query value from the router.
+     * @group Compositions
+     */
+    useQueryValue: ReturnType<typeof createUseQueryValue<TRouter>>;
+    /**
+     * A composition to export much of the functionality that drives RouterLink component.
+     * Also exports some useful context about routes relationship to current URL and convenience methods
+     * for navigating.
+     *
+     * @param source - The name of the route or a valid URL.
+     * @param params - If providing route name, this argument will expect corresponding params.
+     * @param options - {@link RouterResolveOptions} Same options as router resolve.
+     * @returns {UseLink} Reactive context values for as well as navigation methods.
+     * @group Compositions
+     */
+    useLink: ReturnType<typeof createUseLink<TRouter>>;
+};
+export declare function createRouterAssets<TRouter extends Router>(router: TRouter): RouterAssets<TRouter>;
+export declare function createRouterAssets<TRouter extends Router>(routerKey: InjectionKey<TRouter>): RouterAssets<TRouter>;
+export {};

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/createRouterHistory.browser.spec.d.ts

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

package/dist/services/createRouterHistory.d.ts

@@ -0,0 +1,20 @@
+import { History, Listener } from 'history';
+type NavigationPushOptions = {
+    replace?: boolean;
+    state?: unknown;
+};
+type NavigationUpdate = (url: string, options?: NavigationPushOptions) => void;
+type NavigationRefresh = () => void;
+export type RouterHistory = History & {
+    update: NavigationUpdate;
+    refresh: NavigationRefresh;
+    startListening: () => void;
+    stopListening: () => void;
+};
+export type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
+type RouterHistoryOptions = {
+    listener: Listener;
+    mode?: RouterHistoryMode;
+};
+export declare function createRouterHistory({ mode, listener }: RouterHistoryOptions): RouterHistory;
+export {};

package/dist/services/createRouterHooks.d.ts

@@ -0,0 +1,20 @@
+import { AddGlobalRouteHooks, AddComponentAfterRouteHook, AddComponentBeforeRouteHook } from '../types/hooks';
+import { HasVueAppStore } from './createVueAppStore';
+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, any>>;
+export type RouterHooks<TRoutes extends Routes, TRejections extends PropertyKey> = HasVueAppStore & {
+    runBeforeRouteHooks: RouterRouteHookBeforeRunner<TRoutes>;
+    runAfterRouteHooks: RouterRouteHookAfterRunner<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>, RouterRejections<TRouter>>;

package/dist/services/createRouterKeyStore.d.ts

@@ -0,0 +1,3 @@
+import { Router } from '../types/router';
+import { InjectionKey } from 'vue';
+export declare function createRouterKeyStore<TValue>(): (routerKey: InjectionKey<Router>) => InjectionKey<TValue>;

package/dist/services/createRouterPlugin.browser.spec.d.ts

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

package/dist/services/createRouterPlugin.d.ts

@@ -0,0 +1,4 @@
+import { Routes } from '../types/route';
+import { RouterPlugin } from '../types/routerPlugin';
+import { Component } from 'vue';
+export declare function createRouterPlugin<TRoutes extends Routes = [], TRejections extends Record<string, Component> = {}>(plugin: Partial<RouterPlugin<TRoutes, TRejections>>): RouterPlugin<TRoutes, TRejections>;

package/dist/services/createRouterReject.d.ts

@@ -0,0 +1,16 @@
+import { Ref, Component } from 'vue';
+import { ResolvedRoute } from '../types/resolved';
+export type BuiltInRejectionType = 'NotFound';
+export type RouterSetReject = (type: string | null) => void;
+type GetRejectionRoute = (type: string) => ResolvedRoute;
+export type RouterRejection = Ref<null | {
+    type: string;
+    component: Component;
+}>;
+export type CreateRouterReject = {
+    setRejection: RouterSetReject;
+    rejection: RouterRejection;
+    getRejectionRoute: GetRejectionRoute;
+};
+export declare function createRouterReject(rejections: Partial<Record<string, Component>>): CreateRouterReject;
+export {};

package/dist/services/createRouterRoute.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey } from 'vue';
+import { ResolvedRoute } from '../types/resolved';
+import { RouterRoute } from '../types/routerRoute';
+import { RouterPush } from '../types/routerPush';
+import { Router } from '../types/router';
+export declare function isRouterRoute(routerKey: InjectionKey<Router>, value: unknown): value is RouterRoute;
+export declare function createRouterRoute<TRoute extends ResolvedRoute>(routerKey: InjectionKey<Router>, route: TRoute, push: RouterPush): RouterRoute<TRoute>;

package/dist/services/createRouterRoute.spec.d.ts

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

package/dist/services/createUniqueIdSequence.d.ts

@@ -0,0 +1,2 @@
+export declare function createUniqueIdSequence(): () => string;
+export declare function isFirstUniqueSequenceId(id: string): boolean;

package/dist/services/createVisibilityObserver.d.ts

@@ -0,0 +1,7 @@
+export type VisibilityObserver = {
+    observe: (element: Element) => void;
+    unobserve: (element: Element) => void;
+    disconnect: () => void;
+    isElementVisible: (element: Element) => boolean;
+};
+export declare function createVisibilityObserver(): VisibilityObserver;

package/dist/services/createVueAppStore.d.ts

@@ -0,0 +1,8 @@
+import { App } from 'vue';
+export type HasVueAppStore = {
+    setVueApp: (app: App) => void;
+};
+export type VueAppStore = HasVueAppStore & {
+    runWithContext: <T>(callback: () => T) => T;
+};
+export declare function createVueAppStore(): VueAppStore;

package/dist/services/getGlobalHooksForRouter.d.ts

@@ -0,0 +1,4 @@
+import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { RouterOptions } from '../types/router';
+import { RouterPlugin } from '../types/routerPlugin';
+export declare function getGlobalHooksForRouter(options?: RouterOptions, plugins?: RouterPlugin[]): RouterRouteHooks;

package/dist/services/getGlobalRouteHooks.d.ts

@@ -0,0 +1,5 @@
+import { ResolvedRoute } from '../types/resolved';
+import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { Routes } from '../main';
+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/getInitialUrl.browser.spec.d.ts

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

package/dist/services/getInitialUrl.d.ts

@@ -0,0 +1 @@
+export declare function getInitialUrl(initialUrl?: string): string;

package/dist/services/getInitialUrl.spec.d.ts

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

package/dist/services/getMatchesForUrl.d.ts

@@ -0,0 +1,2 @@
+import { Route, Routes } from '../types/route';
+export declare function getMatchesForUrl(routes: Routes, url: string): Route[];

package/dist/services/getMatchesForUrl.spec.d.ts

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

package/dist/services/getParamsForString.d.ts

@@ -0,0 +1,2 @@
+import { Param } from '../types/paramTypes';
+export declare function getParamsForString(string?: string, params?: Record<string, Param | undefined>): Record<string, Param>;

package/dist/services/getRouteHooks.d.ts

@@ -0,0 +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/services/getRouteHooks.spec.d.ts

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

package/dist/services/getRoutesForRouter.d.ts

@@ -0,0 +1,9 @@
+import { Routes } from '../types/route';
+import { RouterPlugin } from '../types/routerPlugin';
+/**
+ * Takes in routes and plugins and returns a list of routes with the base route inserted if provided.
+ * Also checks for duplicate names in the routes.
+ *
+ * @throws {DuplicateNamesError} If there are duplicate names in the routes.
+ */
+export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?: RouterPlugin[], base?: string): Routes;

package/dist/services/getRoutesForRouter.spec.d.ts

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

package/dist/services/hooks.browser.spec.d.ts

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

package/dist/services/hooks.d.ts

@@ -0,0 +1,8 @@
+import { RouteHookLifecycle } from '../types/hooks';
+import { ResolvedRoute } from '../types/resolved';
+type RouteHookCondition = (to: ResolvedRoute, from: ResolvedRoute | null, depth: number) => boolean;
+export declare const isRouteEnter: RouteHookCondition;
+export declare const isRouteLeave: RouteHookCondition;
+export declare const isRouteUpdate: RouteHookCondition;
+export declare function getRouteHookCondition(lifecycle: RouteHookLifecycle): RouteHookCondition;
+export {};

package/dist/services/hooks.spec.d.ts

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