@kitbag/router 0.5.1 → 0.5.3

package/dist/kitbag-router.d.ts

@@ -153,7 +153,7 @@ declare type CombinePath<TParent extends Path, TChild extends Path> = ToPath<TPa
 } ? ToPath<TChild> extends {
     path: infer TChildPath extends string;
     params: infer TChildParams extends Record<string, unknown>;
-} ? MergeParams<TParentParams, TChildParams> extends PathParams<`${TParentPath}${TChildPath}`> ? Path<`${TParentPath}${TChildPath}`, MergeParams<TParentParams, TChildParams>> : Path<'', {}> : Path<'', {}> : Path<'', {}>;
+} ? MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>> extends PathParamsWithParamNameExtracted<`${TParentPath}${TChildPath}`> ? Path<`${TParentPath}${TChildPath}`, MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>>> : Path<'', {}> : Path<'', {}> : Path<'', {}>;
 
 declare type CombineQuery<TParent extends Query | undefined, TChild extends Query | undefined> = ToQuery<TParent> extends {
     query: infer TParentQuery extends string;
@@ -161,7 +161,7 @@ declare type CombineQuery<TParent extends Query | undefined, TChild extends Quer
 } ? ToQuery<TChild> extends {
     query: infer TChildQuery extends string;
     params: infer TChildParams extends Record<string, unknown>;
-} ? MergeParams<TParentParams, TChildParams> extends QueryParams<CombineQueryString<TParentQuery, TChildQuery>> ? Query<CombineQueryString<TParentQuery, TChildQuery>, MergeParams<TParentParams, TChildParams>> : Query<'', {}> : Query<'', {}> : Query<'', {}>;
+} ? MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>> extends QueryParamsWithParamNameExtracted<CombineQueryString<TParentQuery, TChildQuery>> ? Query<CombineQueryString<TParentQuery, TChildQuery>, MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>>> : Query<'', {}> : Query<'', {}> : Query<'', {}>;
 
 declare type CombineQueryString<TParent extends string | undefined, TChild extends string | undefined> = StringHasValue<TParent> extends true ? StringHasValue<TChild> extends true ? `${TParent}&${TChild}` : TParent : TChild;
 
@@ -246,11 +246,13 @@ export declare class DuplicateParamsError extends Error {
     constructor(paramName: string);
 }
 
+declare type ExternalChildRoutes = Route<string, never>[];
+
 declare type ExternalRouteChildProps = {
     /**
      * Represents the host for this route. Used for external routes.
      */
-    host?: string;
+    host?: string | Host;
     /**
      * Name for route, used to create route keys and in navigation.
      */
@@ -277,7 +279,7 @@ declare type ExternalRouteParentProps = {
     /**
      * Represents the host for this route. Used for external routes.
      */
-    host?: string;
+    host?: string | Host;
     /**
      * Name for route, used to create route keys and in navigation.
      */
@@ -297,13 +299,11 @@ declare type ExternalRouteParentProps = {
     /**
      * Children routes, expected type comes from `createExternalRoutes()`
      */
-    children: ExternalRoutes;
+    children: ExternalChildRoutes;
 };
 
 declare type ExternalRouteProps = ExternalRouteParentProps | ExternalRouteChildProps;
 
-declare type ExternalRoutes = Route<string, '', Path, Query, boolean>[];
-
 /**
  * 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.
@@ -311,6 +311,10 @@ declare type ExternalRoutes = Route<string, '', Path, Query, boolean>[];
  */
 export declare type ExtractParamName<TParam extends PropertyKey> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
 
+declare type ExtractParamsFromHostString<THost extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = THost extends `${string}${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? MergeParams<{
+    [P in Param]: ExtractPathParamType<Param, TParams>;
+}, ExtractParamsFromHostString<Rest, TParams>> : Record<never, never>;
+
 declare type ExtractParamsFromPathString<TPath extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TPath extends `${string}${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? MergeParams<{
     [P in Param]: ExtractPathParamType<Param, TParams>;
 }, ExtractParamsFromPathString<Rest, TParams>> : Record<never, never>;
@@ -368,21 +372,24 @@ export declare type ExtractRouteParamTypes<TRoute> = TRoute extends {
 } ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : {};
 
 declare type ExtractRouteParamTypesWithoutLosingOptional<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>;
     };
-} ? ExtractParamTypesWithoutLosingOptional<MergeParams<PathParams, QueryParams>> : Record<string, unknown>;
+} ? ExtractParamTypesWithoutLosingOptional<MergeParams<HostParams, MergeParams<PathParams, QueryParams>>> : Record<string, unknown>;
 
 declare type Flatten<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends unknown[] ? Flatten<[...First, ...Flatten<Rest>]> : [First, ...Flatten<Rest>] : [];
 
 declare type FlattenRoute<TRoute extends RouteProps | ExternalRouteProps, TKey extends string = TRoute extends {
     name: infer T extends string;
-} ? T : '', THost extends string = TRoute extends {
-    host: infer T extends string;
-} ? T : '', TPath extends Path = ToPath<TRoute['path']>, TQuery extends Query = ToQuery<TRoute['query']>, TDisabled extends boolean = TRoute['disabled'] extends boolean ? TRoute['disabled'] : false, TChildren extends Route[] = ExtractRouteChildren<TRoute>> = [
+} ? T : '', THost extends Host = TRoute extends {
+    host: infer T extends Host | string;
+} ? ToHost<T> : never, TPath extends Path = ToPath<TRoute['path']>, TQuery extends Query = ToQuery<TRoute['query']>, TDisabled extends boolean = TRoute['disabled'] extends boolean ? TRoute['disabled'] : false, TChildren extends Route[] = ExtractRouteChildren<TRoute>> = [
 Route<TKey, THost, TPath, TQuery, TDisabled>,
 ...{
     [K in keyof TChildren]: Route<CombineName<TKey, TChildren[K]['key']>, THost, CombinePath<TPath, TChildren[K]['path']>, CombineQuery<TQuery, TChildren[K]['query']>, TChildren[K]['disabled']>;
@@ -395,6 +402,16 @@ declare type FlattenRoutes<TRoutes extends Readonly<RouteProps[] | ExternalRoute
 }
 ]>;
 
+declare type Host<THost extends string = string, TParams extends HostParamsWithParamNameExtracted<THost> = Record<string, Param | undefined>> = {
+    host: THost;
+    params: string extends THost ? Record<string, Param> : Identity<ExtractParamsFromHostString<THost, TParams>>;
+    toString: () => string;
+};
+
+declare type HostParamsWithParamNameExtracted<THost extends string> = {
+    [K in keyof ExtractParamsFromHostString<THost> as ExtractParamName<K>]?: Param;
+};
+
 declare type Identity<T> = T extends object ? {} & {
     [P in keyof T as T[P] extends never ? never : P]: T[P];
 } : T;
@@ -624,10 +641,6 @@ declare type Path<TPath extends string = string, TParams extends PathParamsWithP
  */
 export declare function path<TPath extends string, TParams extends PathParamsWithParamNameExtracted<TPath>>(path: TPath, params: Identity<TParams>): Path<TPath, TParams>;
 
-declare type PathParams<TPath extends string> = {
-    [K in keyof ExtractParamsFromPathString<TPath>]?: Param;
-};
-
 declare type PathParamsWithParamNameExtracted<TPath extends string> = {
     [K in keyof ExtractParamsFromPathString<TPath> as ExtractParamName<K>]?: Param;
 };
@@ -667,10 +680,6 @@ declare type Query<TQuery extends string = string, TQueryParams extends QueryPar
  */
 export declare function query<TQuery extends string, TParams extends QueryParamsWithParamNameExtracted<TQuery>>(query: TQuery, params: Identity<TParams>): Query<TQuery, TParams>;
 
-declare type QueryParams<T extends string> = {
-    [K in keyof ExtractQueryParamsFromQueryString<T>]?: Param;
-};
-
 declare type QueryParamsWithParamNameExtracted<T extends string> = {
     [K in keyof ExtractQueryParamsFromQueryString<T> as ExtractParamName<K>]?: Param;
 };
@@ -737,13 +746,19 @@ export declare type RegisteredRouterState = Register extends {
  */
 export declare type RegisteredRoutes = Register extends {
     router: Router<infer TRoutes extends Routes>;
-} ? TRoutes : Route<string, '', Path<'', {}>, Query<'', {}>, false>[];
+} ? TRoutes : Route<string, Host, Path, Query, false>[];
 
 /**
  * Represents the union of all possible RouteKeys registered within {@link Register}
  */
 export declare type RegisteredRoutesKey = RoutesKey<RegisteredRoutes>;
 
+declare type RemoveLeadingQuestionMark<T extends PropertyKey> = T extends `?${infer TRest extends string}` ? TRest : T;
+
+declare type RemoveLeadingQuestionMarkFromKeys<T extends Record<string, unknown>> = {
+    [K in keyof T as RemoveLeadingQuestionMark<K>]: T[K];
+};
+
 /**
  * Represents a route that the router has matched to current browser location.
  * @template TRoute - Underlying Route that has been resolved.
@@ -784,7 +799,7 @@ declare type ResolvedRouteQuery = {
  * @template TQuery - The type or structure of the query parameters associated with the route.
  * @template TDisabled - Indicates whether the route is disabled, which could affect routing logic.
  */
-export declare type Route<TKey extends string = string, THost extends string = string, TPath extends Path = Path, TQuery extends Query = Query, TDisabled extends boolean = boolean> = {
+export declare type Route<TKey extends string = string, THost extends Host = Host, TPath extends Path = Path, TQuery extends Query = Query, TDisabled extends boolean = boolean> = {
     /**
      * The specific route properties that were matched in the current route.
      */
@@ -1181,6 +1196,8 @@ export declare function throwIfDuplicateParamsAreFound(routes: Route[]): void;
 
 declare type ToCallback = (resolve: RegisteredRouter['resolve']) => string;
 
+declare type ToHost<T extends string | Host> = T extends string ? Host<T, {}> : T;
+
 declare type ToPath<T extends string | Path> = T extends string ? Path<T, {}> : T;
 
 declare type ToQuery<T extends string | Query | undefined> = T extends string ? Query<T, {}> : T extends undefined ? Query<'', {}> : unknown extends T ? Query<'', {}> : T;