@kitbag/router 0.20.5 → 0.20.7

package/dist/services/routeMatchScore.d.ts

@@ -0,0 +1,7 @@
+import { Route } from '../types/route';
+import { QuerySource } from '../types/querySource';
+type RouteSortMethod = (aRoute: Route, bRoute: Route) => number;
+export declare function getRouteScoreSortMethod(url: string): RouteSortMethod;
+export declare function countExpectedPathParams(route: Route, actualPath: string): number;
+export declare function countExpectedQueryParams(route: Route, actual: QuerySource): number;
+export {};

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

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

package/dist/services/routeRegex.d.ts

@@ -0,0 +1,18 @@
+import { Route } from '../types/route';
+import { WithParams } from './withParams';
+export declare function splitByMatches(string: string, regexp: RegExp): string[];
+export declare function generateRoutePathRegexPattern(route: Route): RegExp;
+export declare function generateRouteQueryRegexPatterns(route: Route): RegExp[];
+export declare function replaceParamSyntaxWithCatchAlls(value: string): string;
+export declare function replaceIndividualParamWithCaptureGroup(path: string, paramName: string): string;
+export declare function paramIsOptional(path: WithParams, paramName: string): boolean;
+export declare function isOptionalParamSyntax(value: string): boolean;
+export declare function isRequiredParamSyntax(value: string): boolean;
+export declare const paramRegex = "\\[\\??([\\w-_]+)\\]";
+export declare const optionalParamRegex = "\\[\\?([\\w-_]+)\\]";
+export declare const requiredParamRegex = "\\[([\\w-_]+)\\]";
+export declare const regexCatchAll = ".*";
+export declare const regexCaptureAll = "(.*)";
+export declare function getParamName(value: string): string | undefined;
+export declare function getParamRegexPattern(paramName: string): RegExp;
+export declare function getCaptureGroups(value: string, pattern: RegExp): (string | undefined)[];

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

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

package/dist/services/state.d.ts

@@ -0,0 +1,9 @@
+import { Param } from '../types/paramTypes';
+/**
+ * This function is used to get the values inside the state converted from string values into the correct type.
+ */
+export declare function getStateValues(params: Record<string, Param>, state: unknown): Record<string, unknown>;
+/**
+ * This function is used to set the values inside the state to have string values, stored in history.
+ */
+export declare const setStateValues: (params: Record<string, Param>, state: unknown) => Record<string, string | undefined>;

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

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

package/dist/services/tupleOf.d.ts

@@ -0,0 +1,10 @@
+import { Param, ParamGetSet } from '../types/paramTypes';
+import { ExtractParamType } from '../types/params';
+type TupleOfOptions = {
+    separator?: string;
+};
+type TupleOf<T extends Param[]> = {
+    [K in keyof T]: ExtractParamType<T[K]>;
+};
+export declare function tupleOf<const T extends Param[]>(params: T, options?: TupleOfOptions): ParamGetSet<TupleOf<T>>;
+export {};

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

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

package/dist/services/unionOf.d.ts

@@ -0,0 +1,3 @@
+import { Param, ParamGetSet } from '../types/paramTypes';
+import { ExtractParamType } from '../types/params';
+export declare function unionOf<const T extends Param[]>(params: T): ParamGetSet<ExtractParamType<T[number]>>;

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

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

package/dist/services/urlAssembly.d.ts

@@ -0,0 +1,10 @@
+import { Route } from '../types/route';
+import { Url } from '../types/url';
+import { QuerySource } from '../types/querySource';
+type AssembleUrlOptions = {
+    params?: Record<string, unknown>;
+    query?: QuerySource;
+    hash?: string;
+};
+export declare function assembleUrl(route: Route, options?: AssembleUrlOptions): Url;
+export {};

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

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

package/dist/services/urlCombine.d.ts

@@ -0,0 +1,2 @@
+import { Url, UrlParts } from '../types/url';
+export declare function combineUrl(previous: Url | Partial<UrlParts>, updated: Url | Partial<UrlParts>): Url;

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

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

package/dist/services/urlCreator.d.ts

@@ -0,0 +1,2 @@
+import { Url, UrlParts } from '../types/url';
+export declare function createUrl({ protocol, host, pathname, search, searchParams, hash }: Partial<UrlParts>): Url;

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

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

package/dist/services/urlParser.d.ts

@@ -0,0 +1,2 @@
+import { UrlParts } from '../types/url';
+export declare function parseUrl(value: string): UrlParts;

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

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

package/dist/services/valibot.d.ts

@@ -0,0 +1,7 @@
+import { Param, ParamGetSet } from '../types/paramTypes';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+export interface ValibotSchemaLike extends StandardSchemaV1<any> {
+    type: string;
+}
+export declare function isValibotParam(value: Param): value is ValibotSchemaLike;
+export declare function createValibotParam<T>(schema: ValibotSchemaLike): ParamGetSet<T>;

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

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

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

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

package/dist/services/withDefault.d.ts

@@ -0,0 +1,5 @@
+import { ExtractParamType } from '../types/params';
+import { Param, ParamGetSet } from '../types/paramTypes';
+export type ParamWithDefault<TParam extends Param = Param> = Required<ParamGetSet<ExtractParamType<TParam>>>;
+export declare function isParamWithDefault(param: Param): param is ParamWithDefault;
+export declare function withDefault<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;

package/dist/services/withParams.d.ts

@@ -0,0 +1,15 @@
+import { ExtractParamName, ParamEnd, ParamStart } from '../types/params';
+import { Param } from '../types/paramTypes';
+import { Identity } from '../types/utilities';
+import { MakeOptional } from '../utilities/makeOptional';
+type WithParamsParamsInput<TValue extends string> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? Record<ExtractParamName<TParam>, Param | undefined> & WithParamsParamsInput<Rest> : {};
+type WithParamsParamsOutput<TValue extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? ExtractParamName<TParam> extends keyof TParams ? Record<ExtractParamName<TParam>, TParams[ExtractParamName<TParam>]> & WithParamsParamsOutput<Rest, TParams> : Record<ExtractParamName<TParam>, StringConstructor> & WithParamsParamsOutput<Rest, TParams> : {};
+export type WithParams<TValue extends string = string, TParams extends Record<string, Param | undefined> = Record<string, Param | undefined>> = {
+    value: TValue;
+    params: string extends TValue ? Record<string, Param> : Identity<WithParamsParamsOutput<TValue, TParams>>;
+};
+export type ToWithParams<T extends string | WithParams | undefined> = T extends string ? WithParams<T, {}> : T extends undefined ? WithParams<'', {}> : unknown extends T ? WithParams<'', {}> : T;
+export declare function toWithParams<T extends string | WithParams | undefined>(value: T): ToWithParams<T>;
+export declare function withParams<const TValue extends string, const TParams extends MakeOptional<WithParamsParamsInput<TValue>>>(value: TValue, params: TParams): WithParams<TValue, TParams>;
+export declare function withParams(): WithParams<'', {}>;
+export {};

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

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

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

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

package/dist/services/zod.d.ts

@@ -0,0 +1,11 @@
+import { ParamGetSet } from '../types/paramTypes';
+import { Routes } from '../types/route';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { ZodSchema } from 'zod';
+export interface ZodSchemaLike extends StandardSchemaV1<any> {
+    parse: (input: any) => any;
+}
+export declare function zotParamsDetected(routes: Routes): boolean;
+export declare function initZod(): Promise<void>;
+export declare function isZodParam(value: unknown): value is ZodSchema;
+export declare function createZodParam<T>(schema: ZodSchema<T>): ParamGetSet<T>;

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

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

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

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

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

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

package/dist/tests/routeProps.browser.spec.d.ts

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

package/dist/tests/routeProps.spec.d.ts

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

package/dist/types/createRouteOptions.d.ts

@@ -0,0 +1,120 @@
+import { Component } from 'vue';
+import { CombineHash } from '../services/combineHash';
+import { CombineMeta } from '../services/combineMeta';
+import { CombinePath } from '../services/combinePath';
+import { CombineQuery } from '../services/combineQuery';
+import { CombineState } from '../services/combineState';
+import { Param } from './paramTypes';
+import { PrefetchConfig } from './prefetch';
+import { RouteMeta } from './register';
+import { Route } from './route';
+import { ResolvedRoute } from './resolved';
+import { ComponentProps } from '../services/component';
+import { PropsCallbackContext } from './props';
+import { MaybePromise } from './utilities';
+import { RouterView } from '../main';
+import { ToMeta } from './meta';
+import { ToState } from './state';
+import { ToName } from './name';
+import { WithHooks } from './hooks';
+import { ToWithParams, WithParams } from '../services/withParams';
+export type WithHost<THost extends string | WithParams = string | WithParams> = {
+    /**
+     * Host part of URL.
+     */
+    host: THost;
+};
+export type WithoutHost = {
+    host?: never;
+};
+export type WithParent<TParent extends Route = Route> = {
+    parent: TParent;
+};
+export declare function isWithParent<T extends Record<string, unknown>>(options: T): options is T & WithParent;
+export type WithoutParent = {
+    parent?: never;
+};
+export declare function isWithComponent<T extends Record<string, unknown>>(options: T): options is T & {
+    component: Component;
+};
+export declare function isWithComponentProps<T extends Record<string, unknown>>(options: T): options is T & {
+    props: PropsGetter;
+};
+export declare function isWithComponents<T extends Record<string, unknown>>(options: T): options is T & {
+    components: Record<string, Component>;
+};
+export declare function isWithComponentPropsRecord<T extends Record<string, unknown>>(options: T): options is T & {
+    props: RoutePropsRecord;
+};
+export type CreateRouteOptions<TName extends string | undefined = string | undefined, TPath extends string | WithParams | undefined = string | WithParams | undefined, TQuery extends string | WithParams | undefined = string | WithParams | undefined, THash extends string | WithParams | undefined = string | WithParams | undefined, TMeta extends RouteMeta = RouteMeta> = WithHooks & {
+    /**
+     * Name for route, used to create route keys and in navigation.
+     */
+    name?: TName;
+    /**
+     * Path part of URL.
+     */
+    path?: TPath;
+    /**
+     * Query (aka search) part of URL.
+     */
+    query?: TQuery;
+    /**
+     * Hash part of URL.
+     */
+    hash?: THash;
+    /**
+     * Represents additional metadata associated with a route, customizable via declaration merging.
+     */
+    meta?: TMeta;
+    /**
+     * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
+     */
+    prefetch?: PrefetchConfig;
+    /**
+     * Type params for additional data intended to be stored in history state, all keys will be optional unless a default is provided.
+     */
+    state?: Record<string, Param>;
+    /**
+     * An optional parent route to nest this route under.
+     */
+    parent?: Route;
+    /**
+     * An optional component to render when this route is matched.
+     *
+     * @default RouterView
+     */
+    component?: Component;
+    /**
+     * An object of named components to render using named views
+     */
+    components?: Record<string, Component>;
+    /**
+     * Props have been moved to the second argument of `createRoute`. This property can no longer be used.
+     *
+     * @deprecated
+     */
+    props?: never;
+};
+export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions['parent']>) => MaybePromise<ComponentProps<TComponent>>;
+type ComponentPropsAreOptional<TComponent extends Component> = Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? true : false;
+type RoutePropsRecord<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponents extends Record<string, Component> = Record<string, Component>> = {
+    [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends true ? K : never]?: PropsGetter<TOptions, TComponents[K]>;
+} & {
+    [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends false ? K : never]: PropsGetter<TOptions, TComponents[K]>;
+};
+export type CreateRouteProps<TOptions extends CreateRouteOptions = CreateRouteOptions> = TOptions['component'] extends Component ? PropsGetter<TOptions, TOptions['component']> : TOptions['components'] extends Record<string, Component> ? RoutePropsRecord<TOptions, TOptions['components']> : PropsGetter<TOptions, typeof RouterView>;
+type ToMatch<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = Omit<TOptions, 'props'> & {
+    id: string;
+    props: TProps;
+};
+type ToMatches<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = TOptions extends {
+    parent: infer TParent extends Route;
+} ? [...TParent['matches'], ToMatch<TOptions, TProps>] : [ToMatch<TOptions, TProps>];
+export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = CreateRouteOptions extends TOptions ? Route : TOptions extends {
+    parent: infer TParent extends Route;
+} ? Route<ToName<TOptions['name']>, ToWithParams<TParent['host']>, CombinePath<ToWithParams<TParent['path']>, ToWithParams<TOptions['path']>>, CombineQuery<ToWithParams<TParent['query']>, ToWithParams<TOptions['query']>>, CombineHash<ToWithParams<TParent['hash']>, ToWithParams<TOptions['hash']>>, CombineMeta<ToMeta<TParent['meta']>, ToMeta<TOptions['meta']>>, CombineState<ToState<TParent['state']>, ToState<TOptions['state']>>, ToMatches<TOptions, TProps>> : Route<ToName<TOptions['name']>, TOptions extends {
+    host: string | WithParams;
+} ? ToWithParams<TOptions['host']> : WithParams<'', {}>, ToWithParams<TOptions['path']>, ToWithParams<TOptions['query']>, ToWithParams<TOptions['hash']>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, TProps>>;
+export declare function combineRoutes(parent: Route, child: Route): Route;
+export {};

package/dist/types/hooks.d.ts

@@ -0,0 +1,111 @@
+import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { CallbackAbortResponse, CallbackContext, CallbackContextAbort, CallbackPushResponse, CallbackRejectResponse, CallbackSuccessResponse } from '../services/createCallbackContext';
+import { ResolvedRoute } from './resolved';
+import { MaybeArray, MaybePromise } from './utilities';
+import { Routes } from './route';
+import { RouterAfterRouteHook, RouterBeforeRouteHook } from './router';
+/**
+ * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
+ */
+export type WithHooks = {
+    onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
+    onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
+    onBeforeRouteLeave?: MaybeArray<BeforeRouteHook>;
+    onAfterRouteEnter?: MaybeArray<AfterRouteHook>;
+    onAfterRouteUpdate?: MaybeArray<AfterRouteHook>;
+    onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
+};
+export type BeforeHookContext = {
+    to: ResolvedRoute;
+    from: ResolvedRoute | null;
+};
+export type RouteHookBeforeRunner = (context: BeforeHookContext) => Promise<BeforeRouteHookResponse>;
+export type AfterHookContext = {
+    to: ResolvedRoute;
+    from: ResolvedRoute | null;
+};
+export type RouteHookAfterRunner = (context: AfterHookContext) => Promise<AfterRouteHookResponse>;
+export type RouteHookTiming = 'global' | 'component';
+export type BeforeRouteHookRegistration<TRoutes extends Routes> = {
+    lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
+    hook: RouterBeforeRouteHook<TRoutes>;
+    depth: number;
+};
+export type AddComponentBeforeRouteHook<TRoutes extends Routes> = (hook: BeforeRouteHookRegistration<TRoutes>) => RouteHookRemove;
+export type AfterRouteHookRegistration<TRoutes extends Routes> = {
+    lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
+    hook: RouterAfterRouteHook<TRoutes>;
+    depth: number;
+};
+export type AddComponentAfterRouteHook<TRoutes extends Routes> = (hook: AfterRouteHookRegistration<TRoutes>) => RouteHookRemove;
+export type AddGlobalRouteHooks<TRoutes extends Routes> = (hooks: RouterRouteHooks<TRoutes>) => void;
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
+ */
+type RouteHookContext = {
+    from: ResolvedRoute | null;
+    reject: CallbackContext['reject'];
+    push: CallbackContext['push'];
+    replace: CallbackContext['replace'];
+};
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections, push/replace to another route,
+ * as well as aborting current route change.
+ */
+export type BeforeRouteHookContext = RouteHookContext & {
+    abort: CallbackContextAbort;
+};
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
+ */
+export type AfterRouteHookContext = RouteHookContext;
+/**
+ * Represents a function called before a route change, potentially altering the routing operation.
+ * @param to - {@link ResolvedRoute} The resolved route the router is navigating to.
+ * @param context - {@link BeforeRouteHookContext} The context providing functions and state for the routing operation.
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
+ */
+export type BeforeRouteHook = (to: ResolvedRoute, context: BeforeRouteHookContext) => MaybePromise<void>;
+/**
+ * Represents a function called after a route change has occurred.
+ * @param to - {@link ResolvedRoute} The resolved route the router has navigated to.
+ * @param context - {@link AfterRouteHookContext} The context providing functions and state for the routing operation.
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
+ */
+export type AfterRouteHook = (to: ResolvedRoute, context: AfterRouteHookContext) => MaybePromise<void>;
+/**
+ * Generic type representing a route hook, which can be either before or after a route change.
+ */
+export type RouteHook = BeforeRouteHook | AfterRouteHook;
+/**
+ * A function to remove a previously registered route hook.
+ */
+export type RouteHookRemove = () => void;
+/**
+ * Enumerates the lifecycle events for before route hooks.
+ */
+export type BeforeRouteHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
+/**
+ * Enumerates the lifecycle events for after route hooks.
+ */
+export type AfterRouteHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
+/**
+ * Union type for all route hook lifecycle events.
+ */
+export type RouteHookLifecycle = BeforeRouteHookLifecycle | AfterRouteHookLifecycle;
+/**
+ * Type for responses from a before route hook, which may indicate different outcomes such as success, push, reject, or abort.
+ * @template TRoutes - The type of the routes configuration.
+ */
+export type BeforeRouteHookResponse = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse | CallbackAbortResponse;
+/**
+ * Type for responses from an after route hook, which may indicate different outcomes such as success, push, or reject.
+ * @template TRoutes - The type of the routes configuration.
+ */
+export type AfterRouteHookResponse = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse;
+/**
+ * Union type for all possible route hook responses, covering both before and after scenarios.
+ * @template TRoutes - The type of the routes configuration.
+ */
+export type RouteHookResponse = BeforeRouteHookResponse | AfterRouteHookResponse;
+export {};

package/dist/types/meta.d.ts

@@ -0,0 +1,2 @@
+import { RouteMeta } from './register';
+export type ToMeta<TMeta extends RouteMeta | undefined> = TMeta extends undefined ? {} : unknown extends TMeta ? {} : TMeta;

package/dist/types/name.d.ts

@@ -0,0 +1,2 @@
+export type ToName<T extends string | undefined> = T extends string ? T : '';
+export declare function toName<T extends string | undefined>(value: T): ToName<T>;

package/dist/types/paramTypes.d.ts

@@ -0,0 +1,14 @@
+import { ValibotSchemaLike } from '../services/valibot';
+import { ZodSchemaLike } from '../services/zod';
+export type ParamExtras = {
+    invalid: (message?: string) => never;
+};
+export type ParamGetter<T = any> = (value: string, extras: ParamExtras) => T;
+export type ParamSetter<T = any> = (value: T, extras: ParamExtras) => string;
+export type ParamGetSet<T = any> = {
+    get: ParamGetter<T>;
+    set: ParamSetter<T>;
+    defaultValue?: T;
+};
+export type LiteralParam = string | number | boolean;
+export type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | ZodSchemaLike | ValibotSchemaLike | LiteralParam;

package/dist/types/params.d.ts

@@ -0,0 +1,71 @@
+import { LiteralParam, Param, ParamGetSet, ParamGetter } from './paramTypes';
+import { Identity } from './utilities';
+import { MakeOptional } from '../utilities/makeOptional';
+import { Route } from './route';
+import { WithParams } from '../services/withParams';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+export declare const paramStart = "[";
+export type ParamStart = typeof paramStart;
+export declare const paramEnd = "]";
+export type ParamEnd = typeof paramEnd;
+/**
+ * Type guard to check if a value conforms to the ParamGetter type.
+ * @param value - The value to check.
+ * @returns True if the value is a function that is not a constructor.
+ */
+export declare function isParamGetter(value: Param): value is ParamGetter;
+/**
+ * Type guard to check if a value conforms to the ParamGetSet type.
+ * @param value - The value to check.
+ * @returns True if the value is an object with both 'get' and 'set' functions defined.
+ */
+export declare function isParamGetSet(value: Param): value is ParamGetSet;
+/**
+ * Type guard to check if a value conforms to the LiteralParam type.
+ * @param value - The value to check.
+ * @returns True if the value is a string, number, or boolean.
+ */
+export declare function isLiteralParam(value: Param): value is LiteralParam;
+/**
+ * Extracts the parameter name from a string, handling optional parameters denoted by a leading '?'.
+ * @template TParam - The string from which to extract the parameter name.
+ * @returns The extracted parameter name, or never if the parameter string is empty.
+ */
+export type ExtractParamName<TParam extends PropertyKey> = TParam extends string ? TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam : never;
+/**
+ * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
+ * @template TRoute - The route type from which to extract and merge parameter types.
+ * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
+ */
+export type ExtractRouteParamTypesReading<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesReading<TRoute['host']> & ExtractParamTypesReading<TRoute['path']> & ExtractParamTypesReading<TRoute['query']> & ExtractParamTypesReading<TRoute['hash']>>>;
+/**
+ * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
+ * Differs from ExtractRouteParamTypesReading in that optional params with defaults will remain optional.
+ * @template TRoute - The route type from which to extract and merge parameter types.
+ * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
+ */
+export type ExtractRouteParamTypesWriting<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesWriting<TRoute['host']> & ExtractParamTypesWriting<TRoute['path']> & ExtractParamTypesWriting<TRoute['query']> & ExtractParamTypesWriting<TRoute['hash']>>>;
+/**
+ * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
+ * @template TParams - The record of parameter types, possibly including undefined.
+ * @returns A new type with the appropriate properties marked as optional.
+ */
+type ExtractParamTypesReading<TWithParams extends WithParams> = {
+    [K in keyof TWithParams['params']]: TWithParams['value'] extends `${string}${ParamStart}?${K & string}${ParamEnd}${string}` ? TWithParams['params'][K] extends Required<ParamGetSet> ? ExtractParamType<TWithParams['params'][K]> : ExtractParamType<TWithParams['params'][K]> | undefined : ExtractParamType<TWithParams['params'][K]>;
+};
+/**
+ * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
+ * Differs from ExtractParamTypesReading in that optional params with defaults will remain optional.
+ * @template TParams - The record of parameter types, possibly including undefined.
+ * @returns A new type with the appropriate properties marked as optional.
+ */
+type ExtractParamTypesWriting<TWithParams extends WithParams> = {
+    [K in keyof TWithParams['params']]: TWithParams['value'] extends `${string}${ParamStart}?${K & string}${ParamEnd}${string}` ? ExtractParamType<TWithParams['params'][K]> | undefined : ExtractParamType<TWithParams['params'][K]>;
+};
+/**
+ * Extracts the actual type from a parameter type, handling getters and setters.
+ * @template TParam - The parameter type.
+ * @returns The extracted type, or 'string' as a fallback.
+ */
+export type ExtractParamType<TParam extends Param> = Param extends TParam ? unknown : TParam extends ParamGetSet<infer Type> ? Type : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TParam> : TParam extends LiteralParam ? TParam : string;
+export {};

package/dist/types/prefetch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Determines when assets are prefetched.
+ * eager: Fetched immediately
+ * lazy: Fetched when visible
+ */
+export type PrefetchStrategy = 'eager' | 'lazy' | 'intent';
+export type PrefetchConfigOptions = {
+    /**
+     * When true any component that is wrapped in vue's defineAsyncComponent will be prefetched
+     * @default 'eager'
+     */
+    components?: boolean | PrefetchStrategy;
+    /**
+     * When true any props for routes will be prefetched
+     * @default false
+     */
+    props?: boolean | PrefetchStrategy;
+};
+/**
+ * Determines what assets are prefetched. A boolean enables or disables all prefetching.
+ */
+export type PrefetchConfig = boolean | PrefetchStrategy | PrefetchConfigOptions;
+export type PrefetchConfigs = {
+    routerPrefetch?: PrefetchConfig;
+    routePrefetch?: PrefetchConfig;
+    linkPrefetch?: PrefetchConfig;
+};

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,57 @@
+import { BuiltInRejectionType } from '../services/createRouterReject';
+import { Route, Routes } from './route';
+import { Router, RouterOptions } from './router';
+import { RouterPush } from './routerPush';
+import { RouterReplace } from './routerReplace';
+/**
+ * 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}
+ */
+export type RegisteredRoutes<T = Register> = T extends {
+    router: Router<infer TRoutes extends Routes>;
+} ? TRoutes : Route[];
+/**
+ * Represents the possible Rejections registered within {@link Register}
+ */
+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}
+ */
+export type RegisteredRouterPush = RouterPush<RegisteredRoutes>;
+/**
+ * Represents the type for router `replace`, with types for routes registered within {@link Register}
+ */
+export type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
+/**
+ * Type for Router Reject method. Triggers rejections registered within {@link Register}
+ */
+export type RegisteredRouterReject = (type: RegisteredRejectionType) => void;

package/dist/types/register.spec.d.ts

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