@kitbag/router 0.17.4 → 0.17.6

package/dist/kitbag-router.d.ts

@@ -11,7 +11,6 @@ import { PublicProps } from 'vue';
 import { Ref } from 'vue';
 import { UnwrapRef } from 'vue';
 import { VNode } from 'vue';
-import { ZodSchema } from 'zod';
 
 declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
@@ -374,12 +373,11 @@ declare type ExtractParamName<TParam extends PropertyKey> = TParam extends `?${i
 declare type ExtractParamsFromString<TValue extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TValue extends `${string}${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? Record<Param, ExtractWithParamsParamType<Param, TParams>> & ExtractParamsFromString<Rest, TParams> : Record<never, never>;
 
 /**
- * Extracts the actual type from a parameter type, handling getters, setters, and potential undefined values.
- * This type also is responsible for narrowing possibly undefined values when the param has a default value.
+ * 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.
  */
-declare type ExtractParamType<TParam extends Param, TParamKey extends PropertyKey = string> = TParam extends Required<ParamGetSet> ? Exclude<ExtractParamTypeWithoutLosingOptional<TParam, TParamKey>, undefined> : ExtractParamTypeWithoutLosingOptional<TParam, TParamKey>;
+declare type ExtractParamType<TParam extends Param> = TParam extends ParamGetSet<infer Type> ? Type : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends ZodSchemaLike<infer Type> ? Type : TParam extends LiteralParam ? TParam : string;
 
 /**
  * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
@@ -387,37 +385,25 @@ declare type ExtractParamType<TParam extends Param, TParamKey extends PropertyKe
  * @returns A new type with the appropriate properties marked as optional.
  */
 declare type ExtractParamTypes<TParams extends Record<string, Param>> = Identity<MakeOptional<{
-    [K in keyof TParams as ExtractParamName<K>]: ExtractParamType<TParams[K], K>;
+    [K in keyof TParams as ExtractParamName<K>]: ExtractParamType<TParams[K]>;
 }>>;
 
-declare type ExtractParamTypesWithoutLosingOptional<TParams extends Record<string, Param>> = Identity<MakeOptional<{
-    [K in keyof TParams as ExtractParamName<K>]: ExtractParamTypeWithoutLosingOptional<TParams[K], K>;
+/**
+ * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
+ * @template TParams - The record of parameter types, possibly including undefined.
+ * @returns A new type with the appropriate properties marked as optional.
+ */
+declare type ExtractParamTypesWithOptional<TParams extends Record<string, Param>> = Identity<MakeOptional<{
+    [K in keyof TParams as ExtractParamName<K>]: K extends `?${string}` ? TParams[K] extends Required<ParamGetSet> ? ExtractParamType<TParams[K]> : ExtractParamType<TParams[K]> | undefined : ExtractParamType<TParams[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> : TParam extends ZodSchema<infer Type> ? TParamKey extends `?${string}` ? Type | undefined : Type : TParam extends LiteralParam ? TParamKey extends `?${string}` ? TParam | undefined : TParam : TParamKey extends `?${string}` ? string | undefined : string;
-
 /**
  * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
  * This parameter object type represents the expected type when accessing params from router.route or useRoute.
  * @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.
  */
-declare type ExtractRouteParamTypes<TRoute> = TRoute extends {
-    path: {
-        params: infer PathParams extends Record<string, Param>;
-    };
-    query: {
-        params: infer QueryParams extends Record<string, Param>;
-    };
-    host: {
-        params: infer HostParams extends Record<string, Param>;
-    };
-    hash: {
-        params: infer HashParams extends Record<string, Param>;
-    };
-} ? ExtractParamTypes<HostParams & PathParams & QueryParams & HashParams> : {};
-
-declare type ExtractRouteParamTypesWithoutLosingOptional<TRoute> = TRoute extends {
+declare type ExtractRouteParamTypesWithOptional<TRoute> = TRoute extends {
     host: {
         params: infer HostParams extends Record<string, Param>;
     };
@@ -430,9 +416,9 @@ declare type ExtractRouteParamTypesWithoutLosingOptional<TRoute> = TRoute extend
     hash: {
         params: infer HashParams extends Record<string, Param>;
     };
-} ? ExtractParamTypesWithoutLosingOptional<HostParams & PathParams & QueryParams & HashParams> : Record<string, unknown>;
+} ? ExtractParamTypesWithOptional<HostParams & PathParams & QueryParams & HashParams> : Record<string, unknown>;
 
-declare type ExtractRouteStateParamsAsOptional<T extends Record<string, Param>> = ExtractParamTypes<{
+declare type ExtractRouteStateParamsAsOptional<T extends Record<string, Param>> = ExtractParamTypesWithOptional<{
     [K in keyof T as K extends string ? `?${K}` : never]: T[K];
 }>;
 
@@ -610,7 +596,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 | ZodSchema | LiteralParam;
+export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | ZodSchemaLike | LiteralParam;
 
 declare type ParamEnd = typeof paramEnd;
 
@@ -804,7 +790,7 @@ export declare type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
     /**
      * Key value pair for route params, values will be the user provided value from current browser location.
      */
-    params: ExtractRouteParamTypes<TRoute>;
+    params: ExtractRouteParamTypesWithOptional<TRoute>;
     /**
      * Type for additional data intended to be stored in history state.
      */
@@ -925,7 +911,7 @@ export declare type RouteMeta<T = Register> = T extends {
     routeMeta: infer RouteMeta extends Record<string, unknown>;
 } ? RouteMeta : Record<string, unknown>;
 
-declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypesWithoutLosingOptional<RouteGetByKey<TRoutes, TKey>>;
+declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypesWithOptional<RouteGetByKey<TRoutes, TKey>>;
 
 declare 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]>;
@@ -1416,6 +1402,10 @@ declare type WithParent<TParent extends Route = Route> = {
     parent: TParent;
 };
 
+declare type ZodSchemaLike<TOutput = any> = {
+    parse: (input: any) => TOutput;
+};
+
 export { }