@kitbag/router 0.16.0 → 0.17.1

package/dist/kitbag-router.d.ts

@@ -12,6 +12,33 @@ import { Ref } from 'vue';
 import { UnwrapRef } from 'vue';
 import { VNode } from 'vue';
 
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare type __VLS_Props = {
+    name?: string;
+};
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: (props: {
+            route: RouterRoute;
+            component: Component;
+            rejection: UnwrapRef<RouterRejection>;
+        }) => VNode;
+    }> & {
+        default?: (props: {
+            route: RouterRoute;
+            component: Component;
+            rejection: UnwrapRef<RouterRejection>;
+        }) => VNode;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
 declare type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
@@ -81,6 +108,8 @@ export declare type AfterRouteHookResponse = CallbackSuccessResponse | CallbackP
 
 declare type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
 
+export declare function arrayOf<const T extends Param[]>(...params: T): ParamGetSet<ExtractParamType<T[number]>[]>;
+
 declare type AsNamedRoute<T extends Route> = IsRouteUnnamed<T> extends true ? never : T;
 
 /**
@@ -353,7 +382,7 @@ declare type ExtractParamsFromPathString<TPath extends string, TParams extends R
  * @template TParam - The parameter type.
  * @returns The extracted type, or 'string' as a fallback.
  */
-declare type ExtractParamType<TParam extends Param, TParamKey extends PropertyKey = string> = TParam extends ParamGetSet<infer Type> ? TParamKey extends `?${string}` ? TParam extends ParamWithDefault ? Type : Type | undefined : Type : TParam extends ParamGetter ? TParamKey extends `?${string}` ? ReturnType<TParam> | undefined : ReturnType<TParam> : TParamKey extends `?${string}` ? string | undefined : string;
+declare type ExtractParamType<TParam extends Param, TParamKey extends PropertyKey = string> = TParam extends Required<ParamGetSet> ? Exclude<ExtractParamTypeWithoutLosingOptional<TParam, TParamKey>, undefined> : ExtractParamTypeWithoutLosingOptional<TParam, TParamKey>;
 
 /**
  * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
@@ -368,7 +397,7 @@ declare type ExtractParamTypesWithoutLosingOptional<TParams extends Record<strin
     [K in keyof TParams as ExtractParamName<K>]: ExtractParamTypeWithoutLosingOptional<TParams[K], K>;
 }>>;
 
-declare type ExtractParamTypeWithoutLosingOptional<TParam extends Param, TParamKey extends PropertyKey> = TParam extends ParamGetSet<infer Type> ? TParamKey extends `?${string}` ? Type | undefined : Type : TParam extends ParamGetter ? TParamKey extends `?${string}` ? ReturnType<TParam> | undefined : ReturnType<TParam> : TParamKey extends `?${string}` ? string | undefined : string;
+declare type ExtractParamTypeWithoutLosingOptional<TParam extends Param, TParamKey extends PropertyKey> = TParam extends ParamGetSet<infer Type> ? TParamKey extends `?${string}` ? Type | undefined : Type : TParam extends ParamGetter ? TParamKey extends `?${string}` ? ReturnType<TParam> | undefined : ReturnType<TParam> : TParam extends LiteralParam ? TParamKey extends `?${string}` ? TParam | undefined : TParam : TParamKey extends `?${string}` ? string | undefined : string;
 
 /**
  * Determines the type of a path parameter from a record of parameter types, considering optional parameters.
@@ -418,6 +447,10 @@ declare type ExtractStateParams<TRoute> = TRoute extends {
     state: infer TState extends Record<string, Param>;
 } ? ExtractParamTypes<TState> : Record<string, unknown>;
 
+declare 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;
+
 declare type Hash<THash extends string | undefined = string | undefined> = {
     value: THash;
 };
@@ -519,6 +552,8 @@ declare type KeysOfUnion<T> = T extends T ? keyof T : never;
 
 declare type LastInArray<T, TFallback = never> = T extends [...any[], infer Last] ? Last : TFallback;
 
+export declare type LiteralParam = string | number | boolean;
+
 declare type MakeOptional<T> = {
     [P in WithOptionalProperties<T>]?: T[P];
 } & {
@@ -582,7 +617,7 @@ declare type OnlyRequiredProperties<T> = {
     [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
 };
 
-export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON;
+export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | LiteralParam;
 
 declare type ParamEnd = typeof paramEnd;
 
@@ -634,7 +669,7 @@ declare type Path<TPath extends string = string, TParams extends PathParamsWithP
  * })
  * ```
  */
-export declare function path<TPath extends string, TParams extends PathParamsWithParamNameExtracted<TPath>>(value: TPath, params: Identity<TParams>): Path<TPath, TParams>;
+export declare function path<const TPath extends string, const TParams extends PathParamsWithParamNameExtracted<TPath>>(value: TPath, params: TParams): Path<TPath, TParams>;
 
 declare type PathParamsWithParamNameExtracted<TPath extends string> = {
     [K in keyof ExtractParamsFromPathString<TPath> as ExtractParamName<K>]?: Param;
@@ -668,13 +703,22 @@ export declare type PrefetchStrategy = 'eager' | 'lazy' | 'intent';
 /**
  * Context provided to props callback functions
  */
-export declare type PropsCallbackContext = {
+export declare type PropsCallbackContext<TParent extends Route | undefined = Route | undefined> = {
     push: CallbackContext['push'];
     replace: CallbackContext['replace'];
     reject: CallbackContext['reject'];
+    parent: PropsCallbackParent<TParent>;
 };
 
-declare type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext) => MaybePromise<ComponentProps<TComponent>>;
+declare 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;
+
+declare type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions['parent']>) => MaybePromise<ComponentProps<TComponent>>;
 
 declare type Query<TQuery extends string = string, TQueryParams extends QueryParamsWithParamNameExtracted<TQuery> = Record<string, Param | undefined>> = {
     value: TQuery;
@@ -702,7 +746,7 @@ declare type Query<TQuery extends string = string, TQueryParams extends QueryPar
  * })
  * ```
  */
-export declare function query<TQuery extends string, TParams extends QueryParamsWithParamNameExtracted<TQuery>>(value: TQuery, params: Identity<TParams>): Query<TQuery, TParams>;
+export declare function query<const TQuery extends string, const TParams extends QueryParamsWithParamNameExtracted<TQuery>>(value: TQuery, params: TParams): Query<TQuery, TParams>;
 
 declare type QueryParamsWithParamNameExtracted<T extends string> = {
     [K in keyof ExtractQueryParamsFromQueryString<T> as ExtractParamName<K>]?: Param;
@@ -1056,7 +1100,9 @@ to: Url | ResolvedRoute | ToCallback;
 prefetch?: PrefetchConfig;
 } & RouterPushOptions> & Readonly<{}>, {
 prefetch: PrefetchConfig;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLAnchorElement>, Readonly<{
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+element: HTMLAnchorElement;
+}, HTMLAnchorElement>, Readonly<{
     default?: (props: {
         route: ResolvedRoute | undefined;
         isMatch: boolean;
@@ -1201,23 +1247,7 @@ export declare type RouterRoutes<TRoutes extends Routes> = {
     [K in keyof TRoutes]: RouterRoute<ResolvedRoute<TRoutes[K]>>;
 }[number];
 
-export declare const RouterView: __VLS_WithTemplateSlots<DefineComponent<    {
-name?: string;
-}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
-name?: string;
-}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
-    default?: (props: {
-        route: RouterRoute;
-        component: Component;
-        rejection: UnwrapRef<RouterRejection>;
-    }) => VNode;
-}> & {
-    default?: (props: {
-        route: RouterRoute;
-        component: Component;
-        rejection: UnwrapRef<RouterRejection>;
-    }) => VNode;
-}>;
+export declare const RouterView: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
@@ -1273,6 +1303,14 @@ declare type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateR
 
 declare type ToState<TState extends Record<string, Param> | undefined> = TState extends undefined ? Record<string, Param> : unknown extends TState ? {} : TState;
 
+declare type TupleOf<T extends Param[]> = {
+    [K in keyof T]: ExtractParamType<T[K]>;
+};
+
+export declare function tupleOf<const T extends Param[]>(...params: T): ParamGetSet<TupleOf<T>>;
+
+export declare function unionOf<const T extends Param[]>(...params: T): ParamGetSet<ExtractParamType<T[number]>>;
+
 export declare type Url = `http://${string}` | `https://${string}` | `/${string}`;
 
 export declare type UrlParts = {