@kitbag/router 0.20.5 → 0.20.7

package/dist/components/echo.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineSetupFnComponent<{
+    value: string;
+}, {}, {}, {
+    value: string;
+} & {}, import('vue').PublicProps>;
+export default _default;

package/dist/components/helloWorld.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, never, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/rejection.d.ts

@@ -0,0 +1,2 @@
+import { Component } from 'vue';
+export declare function genericRejection(type: string): Component;

package/dist/components/routerLink.browser.spec.d.ts

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

package/dist/components/routerLink.d.ts

@@ -0,0 +1,36 @@
+import { Url } from '../types/url';
+import { ResolvedRoute } from '../types/resolved';
+import { EmitsOptions, InjectionKey, SlotsType, VNode } from 'vue';
+import { Router } from '../types/router';
+import { RouterLinkProps, ToCallback } from '../types/routerLink';
+type RouterLinkSlots = {
+    default?: (props: {
+        route: ResolvedRoute | undefined;
+        isMatch: boolean;
+        isExactMatch: boolean;
+        isActive: boolean;
+        isExactActive: boolean;
+        isExternal: boolean;
+    }) => VNode[];
+};
+export declare function createRouterLink<TRouter extends Router>(routerKey: InjectionKey<TRouter>): import('vue').DefineSetupFnComponent<RouterLinkProps<TRouter>, EmitsOptions, SlotsType<RouterLinkSlots>, import('../main').RouterPushOptions & {
+    to: Url | Readonly<{
+        id: string;
+        matched: import('../main').CreatedRouteOptions;
+        matches: import('../main').CreatedRouteOptions[];
+        name: string;
+        query: URLSearchParams;
+        hash: string;
+        params: {
+            [x: string]: unknown;
+        };
+        state: import('../types/state').ExtractRouteStateParamsAsOptional<Record<string, import('../main').Param>>;
+        href: Url;
+    }> | ToCallback<TRouter>;
+    prefetch?: import('../main').PrefetchConfig;
+} & ({
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+} | {
+    [x: `on${Capitalize<string>}`]: ((...args: never) => any) | undefined;
+}), import('vue').PublicProps>;
+export {};

package/dist/components/routerView.browser.spec.d.ts

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

package/dist/components/routerView.d.ts

@@ -0,0 +1,20 @@
+import { RouterRejection } from '../services/createRouterReject';
+import { RouterRoute } from '../types/routerRoute';
+import { Router } from '../types/router';
+import { Component, EmitsOptions, InjectionKey, SlotsType, UnwrapRef, VNode } from 'vue';
+export type RouterViewProps = {
+    name?: string;
+};
+type RouterViewSlots = {
+    default?: (props: {
+        route: RouterRoute;
+        component: Component;
+        rejection: UnwrapRef<RouterRejection>;
+    }) => VNode;
+};
+export declare function createRouterView<TRouter extends Router>(routerKey: InjectionKey<TRouter>): import('vue').DefineSetupFnComponent<RouterViewProps, EmitsOptions, SlotsType<RouterViewSlots>, RouterViewProps & ({
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+} | {
+    [x: `on${Capitalize<string>}`]: ((...args: never) => any) | undefined;
+}), import('vue').PublicProps>;
+export {};

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

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

package/dist/compositions/useComponentsStore.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey } from 'vue';
+import { ComponentsStore } from '../services/createComponentsStore';
+import { Router } from '../types/router';
+export declare const getComponentsStoreKey: (routerKey: InjectionKey<Router>) => InjectionKey<ComponentsStore>;
+export declare function createUseComponentsStore<TRouter extends Router>(routerKey: InjectionKey<TRouter>): () => ComponentsStore;

package/dist/compositions/useEventListener.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useEventListener<K extends keyof HTMLElementEventMap>(element: Ref<HTMLElement | undefined>, event: K, handler: (event: HTMLElementEventMap[K]) => void): void;

package/dist/compositions/useLink.d.ts

@@ -0,0 +1,16 @@
+import { InjectionKey, MaybeRefOrGetter } from 'vue';
+import { ResolvedRoute } from '../types/resolved';
+import { RouteParamsByKey } from '../types/routeWithParams';
+import { Url } from '../types/url';
+import { AllPropertiesAreOptional } from '../types/utilities';
+import { Router, RouterRouteName, RouterRoutes } from '../types/router';
+import { UseLink, UseLinkOptions } from '../types/useLink';
+type UseLinkArgs<TRouter extends Router, TSource extends RouterRouteName<TRouter>, TParams = RouteParamsByKey<RouterRoutes<TRouter>, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<UseLinkOptions>] : [params: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<UseLinkOptions>];
+type UseLinkFunction<TRouter extends Router> = {
+    <TRouteKey extends RouterRouteName<TRouter>>(name: MaybeRefOrGetter<TRouteKey>, ...args: UseLinkArgs<TRouter, TRouteKey>): UseLink;
+    (url: MaybeRefOrGetter<Url>, options?: MaybeRefOrGetter<UseLinkOptions>): UseLink;
+    (resolvedRoute: MaybeRefOrGetter<ResolvedRoute | undefined>, options?: MaybeRefOrGetter<UseLinkOptions>): UseLink;
+    (source: MaybeRefOrGetter<string | ResolvedRoute | undefined>, paramsOrOptions?: MaybeRefOrGetter<Record<PropertyKey, unknown> | UseLinkOptions>, maybeOptions?: MaybeRefOrGetter<UseLinkOptions>): UseLink;
+};
+export declare function createUseLink<TRouter extends Router>(routerKey: InjectionKey<TRouter>): UseLinkFunction<TRouter>;
+export {};

package/dist/compositions/usePrefetching.d.ts

@@ -0,0 +1,14 @@
+import { InjectionKey, MaybeRefOrGetter, Ref } from 'vue';
+import { PrefetchConfigs } from '../types/prefetch';
+import { ResolvedRoute } from '../types/resolved';
+import { Router } from '../types/router';
+type UsePrefetchingConfig = PrefetchConfigs & {
+    route: ResolvedRoute | undefined;
+};
+type UsePrefetching = {
+    element: Ref<HTMLElement | undefined>;
+    commit: () => void;
+};
+type UsePrefetchingFunction = (config: MaybeRefOrGetter<UsePrefetchingConfig>) => UsePrefetching;
+export declare function createUsePrefetching<TRouter extends Router>(routerKey: InjectionKey<TRouter>): UsePrefetchingFunction;
+export {};

package/dist/compositions/usePropStore.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey } from 'vue';
+import { PropStore } from '../services/createPropStore';
+import { Router } from '../types/router';
+export declare const getPropStoreInjectionKey: (routerKey: InjectionKey<Router>) => InjectionKey<PropStore>;
+type UsePropStore = () => PropStore;
+export declare function createUsePropStore<TRouter extends Router>(routerKey: InjectionKey<TRouter>): UsePropStore;
+export {};

package/dist/compositions/useQueryValue.browser.spec.d.ts

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

package/dist/compositions/useQueryValue.d.ts

@@ -0,0 +1,15 @@
+import { Ref, MaybeRefOrGetter, InjectionKey } from 'vue';
+import { Router } from '../types/router';
+import { Param } from '../types/paramTypes';
+import { ExtractParamType } from '../types/params';
+export type UseQueryValue<T> = {
+    value: Ref<T | null>;
+    values: Ref<T[]>;
+    remove: () => void;
+};
+type UseQueryValueFunction = {
+    (key: MaybeRefOrGetter<string>): UseQueryValue<string>;
+    <TParam extends Param>(key: MaybeRefOrGetter<string>, param: TParam): UseQueryValue<ExtractParamType<TParam>>;
+};
+export declare function createUseQueryValue<TRouter extends Router>(key: InjectionKey<TRouter>): UseQueryValueFunction;
+export {};

package/dist/compositions/useRejection.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey } from 'vue';
+import { RouterRejection } from '../services/createRouterReject';
+import { Router } from '../types/router';
+export declare const getRouterRejectionInjectionKey: (routerKey: InjectionKey<Router>) => InjectionKey<RouterRejection>;
+type UseRejectionFunction = () => RouterRejection;
+export declare function createUseRejection(routerKey: InjectionKey<Router>): UseRejectionFunction;
+export {};

package/dist/compositions/useRoute.browser.spec.d.ts

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

package/dist/compositions/useRoute.d.ts

@@ -0,0 +1,16 @@
+import { InjectionKey } from 'vue';
+import { IsRouteOptions } from '../guards/routes';
+import { Router, RouterRouteName } from '../types/router';
+type UseRouteFunction<TRouter extends Router> = {
+    (): TRouter['route'];
+    <TRouteName extends RouterRouteName<TRouter>>(routeName: TRouteName, options: IsRouteOptions & {
+        exact: true;
+    }): TRouter['route'] & {
+        name: TRouteName;
+    };
+    <TRouteName extends RouterRouteName<TRouter>>(routeName: TRouteName, options?: IsRouteOptions): TRouter['route'] & {
+        name: `${TRouteName}${string}`;
+    };
+};
+export declare function createUseRoute<TRouter extends Router>(routerKey: InjectionKey<TRouter>): UseRouteFunction<TRouter>;
+export {};

package/dist/compositions/useRouter.d.ts

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

package/dist/compositions/useRouterDepth.d.ts

@@ -0,0 +1,8 @@
+import { InjectionKey } from 'vue';
+import { Router } from '../types/router';
+type UseRouterDepthProps = {
+    increment?: boolean;
+};
+type UseRouterDepthFunction = (props?: UseRouterDepthProps) => number;
+export declare function createUseRouterDepth<TRouter extends Router>(routerKey: InjectionKey<TRouter>): UseRouterDepthFunction;
+export {};

package/dist/compositions/useRouterHooks.d.ts

@@ -0,0 +1,4 @@
+import { RouterHooks } from '../services/createRouterHooks';
+import { Router, RouterRoutes } from '../types/router';
+import { InjectionKey } from 'vue';
+export declare function createUseRouterHooks<TRouter extends Router>(routerKey: InjectionKey<TRouter>): () => RouterHooks<RouterRoutes<TRouter>>;

package/dist/compositions/useVisibilityObserver.d.ts

@@ -0,0 +1,8 @@
+import { VisibilityObserver } from '../services/createVisibilityObserver';
+import { InjectionKey, Ref } from 'vue';
+type UseVisibilityObserver = {
+    isElementVisible: Ref<boolean>;
+};
+export declare const visibilityObserverKey: InjectionKey<VisibilityObserver>;
+export declare function useVisibilityObserver(element: Ref<Element | undefined>): UseVisibilityObserver;
+export {};

package/dist/errors/callbackContextAbortError.d.ts

@@ -0,0 +1,5 @@
+import { CallbackAbortResponse } from '../services/createCallbackContext';
+export declare class CallbackContextAbortError extends Error {
+    response: CallbackAbortResponse;
+    constructor();
+}

package/dist/errors/callbackContextPushError.d.ts

@@ -0,0 +1,5 @@
+import { CallbackPushResponse } from '../services/createCallbackContext';
+export declare class CallbackContextPushError extends Error {
+    response: CallbackPushResponse;
+    constructor(to: unknown[]);
+}

package/dist/errors/callbackContextRejectionError.d.ts

@@ -0,0 +1,6 @@
+import { RegisteredRejectionType } from '../types/register';
+import { CallbackRejectResponse } from '../services/createCallbackContext';
+export declare class CallbackContextRejectionError extends Error {
+    response: CallbackRejectResponse;
+    constructor(type: RegisteredRejectionType);
+}

package/dist/errors/duplicateNamesError.d.ts

@@ -0,0 +1,11 @@
+/**
+ * An error thrown when duplicate names are detected in a route.
+ * Names must be unique.
+ */
+export declare class DuplicateNamesError extends Error {
+    /**
+     * Constructs a new DuplicateNamesError instance with a message indicating the problematic name.
+     * @param name - The name of the name that was duplicated.
+     */
+    constructor(name: string);
+}

package/dist/errors/duplicateParamsError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An error thrown when duplicate parameters are detected in a route.
+ * Param names must be unique. This includes params defined in a path
+ * parent and params defined in the query.
+ * @group Errors
+ */
+export declare class DuplicateParamsError extends Error {
+    /**
+     * Constructs a new DuplicateParamsError instance with a message indicating the problematic parameter.
+     * @param paramName - The name of the parameter that was duplicated.
+     */
+    constructor(paramName: string);
+}

package/dist/errors/initialRouteMissingError.d.ts

@@ -0,0 +1,3 @@
+export declare class InitialRouteMissingError extends Error {
+    constructor();
+}

package/dist/errors/invalidRouteParamValueError.d.ts

@@ -0,0 +1,2 @@
+export declare class InvalidRouteParamValueError extends Error {
+}

package/dist/errors/metaPropertyConflict.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An error thrown when a parent's meta has the same key as a child and the types are not compatible.
+ * A child's meta can override properties of the parent, however the types must match!
+ * @group Errors
+ */
+export declare class MetaPropertyConflict extends Error {
+    constructor(property?: string);
+}

package/dist/errors/routeNotFoundError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * An error thrown when attempting to resolve a route that does not exist
+ */
+export declare class RouteNotFoundError extends Error {
+    constructor(source: string);
+}

package/dist/errors/routerNotInstalledError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * An error thrown when an attempt is made to use routing functionality before the router has been installed.
+ * @group Errors
+ */
+export declare class RouterNotInstalledError extends Error {
+    constructor();
+}

package/dist/errors/useRouteInvalidError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An error thrown when there is a mismatch between an expected route and the one actually used.
+ * @group Errors
+ */
+export declare class UseRouteInvalidError extends Error {
+    /**
+     * Constructs a new UseRouteInvalidError instance with a message that specifies both the given and expected route names.
+     * This detailed error message aids in quickly identifying and resolving mismatches in route usage.
+     * @param routeName - The route name that was incorrectly used.
+     * @param actualRouteName - The expected route name that should have been used.
+     */
+    constructor(routeName: string, actualRouteName: string);
+}

package/dist/guards/routes.d.ts

@@ -0,0 +1,46 @@
+import { RouterRoute } from '../types/routerRoute';
+import { Router, RouterRouteName } from '../types/router';
+import { InjectionKey } from 'vue';
+export type IsRouteOptions = {
+    exact?: boolean;
+};
+type RouteWithMatch<TRoute extends RouterRoute, TRouteName extends TRoute['name']> = TRoute extends RouterRoute ? TRouteName extends TRoute['matches'][number]['name'] ? TRoute : never : never;
+type IsRouteFunction<TRouter extends Router> = {
+    /**
+     * A type guard for determining if a value is a valid RouterRoute.
+     * @param route - The value to check.
+     * @returns `true` if the value is a valid RouterRoute, otherwise `false`.
+     * @group Type Guards
+     */
+    (route: unknown): route is RouterRoute;
+    /**
+     * A type guard for determining if a value is a valid RouterRoute with an exact match.
+     * @param route - The value to check.
+     * @param routeName - The expected route name.
+     * @returns `true` if the value is a valid RouterRoute with an exact match, otherwise `false`.
+     * @group Type Guards
+     */
+    <TRoute extends TRouter['route'], TRouteName extends RouterRouteName<TRouter>>(route: TRoute, routeName: TRouteName, options: IsRouteOptions & {
+        exact: true;
+    }): route is TRoute & {
+        name: TRouteName;
+    };
+    /**
+     * A type guard for determining if a value is a valid RouterRoute with a partial match.
+     * @param route - The value to check.
+     * @param routeName - The expected route name.
+     * @returns `true` if the value is a valid RouterRoute with a partial match, otherwise `false`.
+     * @group Type Guards
+     */
+    <TRoute extends TRouter['route'], TRouteName extends TRoute['name']>(route: TRoute, routeName: TRouteName, options?: IsRouteOptions): route is RouteWithMatch<TRoute, TRouteName>;
+    /**
+     * A type guard for determining if a value is a valid RouterRoute.
+     * @param route - The value to check.
+     * @param routeName - The expected route name.
+     * @returns `true` if the value is a valid RouterRoute, otherwise `false`.
+     * @group Type Guards
+     */
+    (route: unknown, routeName?: string, options?: IsRouteOptions): boolean;
+};
+export declare function createIsRoute<TRouter extends Router>(routerKey: InjectionKey<TRouter>): IsRouteFunction<TRouter>;
+export {};

package/dist/guards/routes.spec-d.d.ts

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

package/dist/keys.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { RegisteredRouter } from './types/register';
+export declare const routerInjectionKey: InjectionKey<RegisteredRouter>;