@teardown/navigation 2.0.80 → 2.0.82

package/src/router/index.ts

@@ -2,8 +2,13 @@
  * Router module exports
  */
 
-export type { ExtractRoutePaths, ExtractScreens, TeardownRouterOptions } from "./create-router";
-export { createTeardownRouter } from "./create-router";
+export type {
+	ExtractRoutePaths,
+	ExtractScreens,
+	RouteTreeRouterOptions,
+	TeardownRouterOptions,
+} from "./create-router";
+export { createTeardownRouter, createTeardownRouterFromTree } from "./create-router";
 // Legacy type aliases for backwards compatibility
 export type {
 	DrawerScreenOptions,

package/src/types/index.ts

@@ -2,6 +2,18 @@
  * Type utilities and definitions for @teardown/navigation
  */
 
+// Route builder types
+export type {
+	AccumulateParams,
+	AnyRouteDefinition,
+	ComputeFullPath,
+	ExtractRouteParams,
+	ExtractRoutePaths,
+	MergeRouteParams,
+	ParamsForPath,
+	RouteDefinitionBase,
+	StripRouteGroups,
+} from "./route-builder-types";
 // Route type definitions
 export type {
 	NavigationState,
@@ -22,7 +34,9 @@ export type {
 	InferParams,
 	IsCatchAllSegment,
 	IsDynamicSegment,
+	IsEmptyParams,
 	IsOptionalSegment,
 	NavigateArgs,
 	Simplify,
+	ToReactNavigationPath,
 } from "./type-utils";

package/src/types/route-builder-types.ts

@@ -0,0 +1,103 @@
+/**
+ * Route builder type utilities for @teardown/navigation
+ * Enables compile-time path computation and param accumulation
+ */
+
+import type { InferParams, Simplify } from "./type-utils";
+
+/**
+ * Compute full path from parent chain
+ * Handles route groups by stripping (groupName) segments
+ */
+export type ComputeFullPath<TPath extends string, TParent> = TParent extends {
+	fullPath: infer P extends string;
+}
+	? P extends "/"
+		? `/${StripRouteGroups<TPath>}`
+		: StripRouteGroups<TPath> extends ""
+			? P
+			: `${P}/${StripRouteGroups<TPath>}`
+	: StripRouteGroups<TPath> extends ""
+		? "/"
+		: `/${StripRouteGroups<TPath>}`;
+
+/**
+ * Strip route group segments from path
+ * (auth)/login -> login
+ * (auth) -> ""
+ */
+export type StripRouteGroups<TPath extends string> = TPath extends `(${string})/${infer Rest}`
+	? StripRouteGroups<Rest>
+	: TPath extends `(${string})`
+		? ""
+		: TPath;
+
+/**
+ * Accumulate params from parent chain + this route
+ */
+export type AccumulateParams<TPath extends string, TParent> = Simplify<
+	InferParams<TPath> & (TParent extends { allParams: infer P } ? P : {})
+>;
+
+/**
+ * Base interface for all route definitions (screens and layouts)
+ */
+export interface RouteDefinitionBase<
+	TPath extends string = string,
+	TFullPath extends string = string,
+	TParams = unknown,
+	TAllParams = unknown,
+	TContext = unknown,
+> {
+	/** This route segment path */
+	readonly path: TPath;
+	/** Full path from root */
+	readonly fullPath: TFullPath;
+	/** Params from this route only */
+	readonly params: TParams;
+	/** Accumulated params from parent chain */
+	readonly allParams: TAllParams;
+	/** Loader context type */
+	readonly context: TContext;
+}
+
+/**
+ * Type for any route definition (screen or layout)
+ */
+export type AnyRouteDefinition = RouteDefinitionBase<string, string, unknown, unknown, unknown>;
+
+/**
+ * Extract all route paths from a route tree
+ */
+export type ExtractRoutePaths<T> = T extends { fullPath: infer P extends string }
+	?
+			| P
+			| (T extends { children: infer C }
+					? C extends readonly (infer Child)[]
+						? ExtractRoutePaths<Child>
+						: never
+					: never)
+	: never;
+
+/**
+ * Extract route params map from a route tree
+ */
+export type ExtractRouteParams<T> = T extends { fullPath: infer P extends string; allParams: infer Params }
+	? { [K in P]: Params } & (T extends { children: infer C }
+			? C extends readonly (infer Child)[]
+				? ExtractRouteParams<Child>
+				: {}
+			: {})
+	: {};
+
+/**
+ * Merge two route param maps
+ */
+export type MergeRouteParams<A, B> = Simplify<A & B>;
+
+/**
+ * Get params for a specific path from a route tree
+ */
+export type ParamsForPath<TTree, TPath extends string> = TPath extends keyof ExtractRouteParams<TTree>
+	? ExtractRouteParams<TTree>[TPath]
+	: never;

package/src/types/type-utils.ts

@@ -11,19 +11,46 @@ export type Simplify<T> = { [K in keyof T]: T[K] } & {};
 
 /**
  * Extracts parameter from a single path segment
+ * Supports both [param] and :param syntax
  *
- * - [userId] -> { userId: string }
- * - [...slug] -> { slug: string[] }
- * - [section]? -> { section?: string }
+ * - [userId] or :userId -> { userId: string }
+ * - [...slug] or *slug -> { slug: string[] }
+ * - [section]? or :section? -> { section?: string }
  * - about -> Record<string, never>
  */
-export type ExtractParam<Segment extends string> = Segment extends `[...${infer Rest}]`
-	? { [K in Rest]: string[] }
-	: Segment extends `[${infer Param}]?`
-		? { [K in Param]?: string }
-		: Segment extends `[${infer Param}]`
-			? { [K in Param]: string }
-			: Record<string, never>;
+export type ExtractParam<Segment extends string> =
+	// Catch-all: [...slug] or *slug
+	Segment extends `[...${infer Rest}]`
+		? { [K in Rest]: string[] }
+		: Segment extends `*${infer Rest}`
+			? { [K in Rest]: string[] }
+			: // Optional: [param]? or :param?
+				Segment extends `[${infer Param}]?`
+				? { [K in Param]?: string }
+				: Segment extends `:${infer Param}?`
+					? { [K in Param]?: string }
+					: // Required: [param] or :param
+						Segment extends `[${infer Param}]`
+						? { [K in Param]: string }
+						: Segment extends `:${infer Param}`
+							? { [K in Param]: string }
+							: // Static segment
+								Record<string, never>;
+
+/**
+ * Check if params object is empty (no required params)
+ */
+export type IsEmptyParams<T> = keyof T extends never ? true : false;
+
+/**
+ * Convert [param] syntax to :param syntax for React Navigation
+ */
+export type ToReactNavigationPath<TPath extends string> =
+	TPath extends `${infer Before}[...${infer Param}]${infer After}`
+		? ToReactNavigationPath<`${Before}*${Param}${After}`>
+		: TPath extends `${infer Before}[${infer Param}]${infer After}`
+			? ToReactNavigationPath<`${Before}:${Param}${After}`>
+			: TPath;
 
 /**
  * Recursively extracts all params from a path