@kitbag/router 0.18.0 → 0.18.1

package/dist/kitbag-router.d.ts

@@ -220,7 +220,7 @@ declare type CombinePath<TParent extends WithParams, TChild extends WithParams>
 } ? ToWithParams<TChild> extends {
     value: infer TChildPath extends string;
     params: infer TChildParams extends Record<string, unknown>;
-} ? RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams> extends ParamsWithParamNameExtracted<CombinePathString<TParentPath, TChildPath>> ? WithParams<CombinePathString<TParentPath, TChildPath>, RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams>> : WithParams<'', {}> : WithParams<'', {}> : WithParams<'', {}>;
+} ? RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams> extends Record<string, Param | undefined> ? WithParams<CombinePathString<TParentPath, TChildPath>, RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams>> : WithParams<CombinePathString<TParentPath, TChildPath>, {}> : WithParams<'', {}> : WithParams<'', {}>;
 
 declare type CombinePathString<TParent extends string, TChild extends string> = `${TParent}${TChild}`;
 
@@ -230,7 +230,7 @@ declare type CombineQuery<TParent extends WithParams, TChild extends WithParams>
 } ? ToWithParams<TChild> extends {
     value: infer TChildQuery extends string;
     params: infer TChildParams extends Record<string, unknown>;
-} ? RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams> extends ParamsWithParamNameExtracted<CombineQueryString<TParentQuery, TChildQuery>> ? WithParams<CombineQueryString<TParentQuery, TChildQuery>, RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams>> : WithParams<'', {}> : WithParams<'', {}> : WithParams<'', {}>;
+} ? RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams> extends Record<string, Param | undefined> ? WithParams<CombineQueryString<TParentQuery, TChildQuery>, RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams>> : WithParams<CombineQueryString<TParentQuery, TChildQuery>, {}> : WithParams<'', {}> : WithParams<'', {}>;
 
 declare type CombineQueryString<TParent extends string | undefined, TChild extends string | undefined> = StringHasValue<TParent> extends true ? StringHasValue<TChild> extends true ? `${TParent}&${TChild}` : TParent : TChild;
 
@@ -372,8 +372,6 @@ declare type EmptyRouterPlugin = {
  */
 declare type ExtractParamName<TParam extends PropertyKey> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
 
-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 and setters.
  * @template TParam - The parameter type.
@@ -391,38 +389,44 @@ declare type ExtractParamTypes<TParams extends Record<string, Param>> = Identity
 }>>;
 
 /**
- * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
+ * Does everything that ExtractParamTypes does, but takes into consideration optional properties.
+ * Differs from ExtractParamTypes in that it also reads the string `value` from WithParams to determine what should be optional.
  * @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<{
+declare type ExtractParamTypesOptionalReading<TParams extends Record<string, Param>> = {
     [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]>;
-}>>;
+};
 
 /**
- * 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.
+ * Does everything that ExtractParamTypes does, but takes into consideration optional properties.
+ * Differs from ExtractParamTypesOptionalReading 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.
+ */
+declare type ExtractParamTypesOptionalWriting<TParams extends Record<string, Param>> = {
+    [K in keyof TParams as ExtractParamName<K>]: K extends `?${string}` ? ExtractParamType<TParams[K]> | undefined : ExtractParamType<TParams[K]>;
+};
+
+/**
+ * Does everything that ExtractRouteParamTypes does, but takes into consideration optional properties.
+ * Differs from ExtractRouteParamTypes in that it also reads the string `value` from WithParams to determine what should be 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.
  */
-declare type ExtractRouteParamTypesWithOptional<TRoute> = TRoute extends {
-    host: {
-        params: infer HostParams extends Record<string, Param>;
-    };
-    path: {
-        params: infer PathParams extends Record<string, Param>;
-    };
-    query: {
-        params: infer QueryParams extends Record<string, Param>;
-    };
-    hash: {
-        params: infer HashParams extends Record<string, Param>;
-    };
-} ? ExtractParamTypesWithOptional<HostParams & PathParams & QueryParams & HashParams> : Record<string, unknown>;
+declare type ExtractRouteParamTypesOptionalReading<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesOptionalReading<TRoute['host']['params']> & ExtractParamTypesOptionalReading<TRoute['path']['params']> & ExtractParamTypesOptionalReading<TRoute['query']['params']> & ExtractParamTypesOptionalReading<TRoute['hash']['params']>>>;
 
-declare type ExtractRouteStateParamsAsOptional<T extends Record<string, Param>> = ExtractParamTypesWithOptional<{
-    [K in keyof T as K extends string ? `?${K}` : never]: T[K];
-}>;
+/**
+ * Does everything that ExtractRouteParamTypes does, but takes into consideration optional properties.
+ * Differs from ExtractRouteParamTypesOptionalReading 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.
+ */
+declare type ExtractRouteParamTypesOptionalWriting<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesOptionalWriting<TRoute['host']['params']> & ExtractParamTypesOptionalWriting<TRoute['path']['params']> & ExtractParamTypesOptionalWriting<TRoute['query']['params']> & ExtractParamTypesOptionalWriting<TRoute['hash']['params']>>>;
+
+declare type ExtractRouteStateParamsAsOptional<TParams extends Record<string, Param>> = {
+    [K in keyof TParams]: ExtractParamType<TParams[K]> | undefined;
+};
 
 declare type ExtractStateParams<TRoute> = TRoute extends {
     state: infer TState extends Record<string, Param>;
@@ -622,10 +626,6 @@ declare type ParamStart = typeof paramStart;
 
 declare const paramStart = "[";
 
-declare type ParamsWithParamNameExtracted<TValue extends string> = {
-    [K in keyof ExtractParamsFromString<TValue> as ExtractParamName<K>]?: Param;
-};
-
 declare type ParamWithDefault<TParam extends Param = Param> = Required<ParamGetSet<ExtractParamType<TParam>>>;
 
 /**
@@ -792,7 +792,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: ExtractRouteParamTypesWithOptional<TRoute>;
+    params: ExtractRouteParamTypesOptionalReading<TRoute>;
     /**
      * Type for additional data intended to be stored in history state.
      */
@@ -913,7 +913,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> = ExtractRouteParamTypesWithOptional<RouteGetByKey<TRoutes, TKey>>;
+declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = RouteGetByKey<TRoutes, TKey> extends Route ? ExtractRouteParamTypesOptionalWriting<RouteGetByKey<TRoutes, TKey>> : Record<string, unknown>;
 
 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]>;
@@ -1391,15 +1391,19 @@ declare type WithoutParent = {
     parent?: never;
 };
 
-declare type WithParams<TValue extends string = string, TParams extends ParamsWithParamNameExtracted<TValue> = Record<string, Param | undefined>> = {
+declare 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<ExtractParamsFromString<TValue, TParams>>;
+    params: string extends TValue ? Record<string, Param> : Identity<WithParamsParamsOutput<TValue, TParams>>;
 };
 
-export declare function withParams<const TValue extends string, const TParams extends ParamsWithParamNameExtracted<TValue>>(value: TValue, params: TParams): WithParams<TValue, TParams>;
+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<'', {}>;
 
+declare type WithParamsParamsInput<TValue extends string> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? Record<ExtractParamName<TParam>, Param | undefined> & WithParamsParamsInput<Rest> : {};
+
+declare type WithParamsParamsOutput<TValue extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? Record<TParam, ExtractWithParamsParamType<TParam, TParams>> & WithParamsParamsOutput<Rest, TParams> : {};
+
 declare type WithParent<TParent extends Route = Route> = {
     parent: TParent;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kitbag/router",
   "private": false,
-  "version": "0.18.0",
+  "version": "0.18.1",
   "bugs": {
     "url": "https://github.com/kitbagjs/router/issues"
   },