@kitbag/router 0.20.5 → 0.20.7

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,185 @@
+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, RegisteredRouterReject } 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']>;
+    /**
+     * Registers a hook to be called before a route is left.
+     */
+    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes']>;
+    /**
+     * Registers a hook to be called before a route is updated.
+     */
+    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes | TPlugin['routes']>;
+    /**
+     * Registers a hook to be called after a route is entered.
+     */
+    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes | TPlugin['routes']>;
+    /**
+     * Registers a hook to be called after a route is left.
+     */
+    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes | TPlugin['routes']>;
+    /**
+     * Registers a hook to be called after a route is updated.
+     */
+    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes | TPlugin['routes']>;
+    /**
+    * 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> = {
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+    reject: RegisteredRouterReject;
+    push: RouterPush<TRoutes>;
+    replace: RouterReplace<TRoutes>;
+};
+type RouterBeforeRouteHookContext<TRoutes extends Routes> = RouterHookContext<TRoutes> & {
+    abort: CallbackContextAbort;
+};
+export type HookContext<TRoutes extends Routes> = {
+    to: RouterResolvedRouteUnion<TRoutes>;
+    from: RouterResolvedRouteUnion<TRoutes> | null;
+};
+export type RouterBeforeRouteHook<TRoutes extends Routes> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterBeforeRouteHookContext<TRoutes>) => MaybePromise<void>;
+export type AddRouterBeforeRouteHook<TRoutes extends Routes> = (hook: RouterBeforeRouteHook<TRoutes>) => RouteHookRemove;
+type RouterAfterRouteHookContext<TRoutes extends Routes> = RouterHookContext<TRoutes>;
+export type RouterAfterRouteHook<TRoutes extends Routes> = (to: RouterResolvedRouteUnion<TRoutes>, context: RouterAfterRouteHookContext<TRoutes>) => MaybePromise<void>;
+export type AddRouterAfterRouteHook<TRoutes extends Routes> = (hook: RouterAfterRouteHook<TRoutes>) => RouteHookRemove;
+export type 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 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;

package/dist/types/useLink.d.ts

@@ -0,0 +1,51 @@
+import { ComputedRef, Ref } from 'vue';
+import { PrefetchConfig } from './prefetch';
+import { ResolvedRoute } from './resolved';
+import { RouterPushOptions } from './routerPush';
+import { RouterReplaceOptions } from './routerReplace';
+import { Url } from './url';
+export type UseLink = {
+    /**
+     * A template ref to bind to the dom for automatic prefetching
+     */
+    element: Ref<HTMLElement | undefined>;
+    /**
+     * ResolvedRoute if matched. Same value as `router.find`
+     */
+    route: ComputedRef<ResolvedRoute | undefined>;
+    /**
+     * Resolved URL with params interpolated and query applied. Same value as `router.resolve`.
+     */
+    href: ComputedRef<Url | undefined>;
+    /**
+     * True if route matches current URL or is ancestor of route that matches current URL
+     */
+    isMatch: ComputedRef<boolean>;
+    /**
+     * True if route matches current URL. Route is the same as what's currently stored at `router.route`.
+     */
+    isExactMatch: ComputedRef<boolean>;
+    /**
+     * True if route matches current URL, or is a parent route that matches the parent of the current URL.
+     */
+    isActive: ComputedRef<boolean>;
+    /**
+     * True if route matches current URL exactly.
+     */
+    isExactActive: ComputedRef<boolean>;
+    /**
+     *
+     */
+    isExternal: ComputedRef<boolean>;
+    /**
+     * Convenience method for executing `router.push` with route context passed in.
+     */
+    push: (options?: RouterPushOptions) => Promise<void>;
+    /**
+     * Convenience method for executing `router.replace` with route context passed in.
+     */
+    replace: (options?: RouterReplaceOptions) => Promise<void>;
+};
+export type UseLinkOptions = RouterPushOptions & {
+    prefetch?: PrefetchConfig;
+};

package/dist/types/utilities.d.ts

@@ -0,0 +1,22 @@
+export type Identity<T> = T extends object ? {} & {
+    [P in keyof T as T[P] extends never ? never : P]: T[P];
+} : T;
+type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
+export type MaybeArray<T> = T | T[];
+export type LastInArray<T, TFallback = never> = T extends [...any[], infer Last] ? Last : TFallback;
+export type MaybePromise<T> = T | Promise<T>;
+type OnlyRequiredProperties<T> = {
+    [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
+};
+export type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
+/**
+ * Converts a type to a string if it is a string, otherwise returns never.
+ * Specifically useful when using keyof T to produce a union of strings
+ * rather than string | number | symbol.
+ */
+export type AsString<T> = T extends string ? T : never;
+/**
+ * Extracts the keys of a union type.
+ */
+export type KeysOfUnion<T> = T extends T ? keyof T : never;
+export {};

package/dist/utilities/array.d.ts

@@ -0,0 +1,2 @@
+export declare function asArray<T>(value: Readonly<T | T[]>): T[];
+export declare function getCount<T>(array: T[], item: T): number;

package/dist/utilities/checkDuplicateKeys.d.ts

@@ -0,0 +1 @@
+export declare function checkDuplicateParams(...withParams: (Record<string, unknown> | string[])[]): void;

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

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

package/dist/utilities/checkDuplicateNames.d.ts

@@ -0,0 +1,2 @@
+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/components.d.ts

@@ -0,0 +1,6 @@
+import { Component } from 'vue';
+type ComponentWithAsyncLoader = Component & {
+    __asyncLoader: () => void;
+};
+export declare function isAsyncComponent(component: Component): component is ComponentWithAsyncLoader;
+export {};

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

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

package/dist/utilities/guards.d.ts

@@ -0,0 +1,5 @@
+export declare function isDefined<T>(value: T | undefined): value is T;
+export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+export declare function hasProperty<TSource extends Record<PropertyKey, unknown>, TProperty extends PropertyKey, TType extends () => unknown>(value: TSource, key: TProperty, type?: TType): value is TSource & Record<TProperty, ReturnType<TType>>;
+export declare function stringHasValue(value: string | undefined): value is string;
+export type StringHasValue<T> = string extends T ? true : '' extends T ? false : T extends string ? true : false;

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

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

package/dist/utilities/index.d.ts

@@ -0,0 +1,6 @@
+export * from './array';
+export * from './checkDuplicateKeys';
+export * from './guards';
+export * from './isBrowser';
+export * from './makeOptional';
+export * from './testHelpers';