API Reference

function useTypedNavigation(): TypedNavigation;

interface TypedNavigation {
  navigate<T extends RegisteredRoutePath>(
    ...args: ParamsFor<T> extends undefined ? [path: T] : [path: T, params: ParamsFor<T>]
  ): void;

  push<T extends RegisteredRoutePath>(
    ...args: ParamsFor<T> extends undefined ? [path: T] : [path: T, params: ParamsFor<T>]
  ): void;

  replace<T extends RegisteredRoutePath>(
    ...args: ParamsFor<T> extends undefined ? [path: T] : [path: T, params: ParamsFor<T>]
  ): void;

  goBack(): void;
  canGoBack(): boolean;
  reset<T extends RegisteredRoutePath>(state: NavigationState<T>): void;
  setParams<T extends RegisteredRoutePath>(params: Partial<ParamsFor<T>>): void;
  getParent(): TypedNavigation | undefined;
  isFocused(): boolean;
}

function useTypedParams<T extends RegisteredRoutePath>(): ParamsFor<T>;

const { userId } = useTypedParams<"/users/:userId">();

function useTypedRoute<T extends RegisteredRoutePath>(): TypedRoute<T>;

interface TypedRoute<T> {
  name: string;
  params: ParamsFor<T>;
  key: string;
}

function defineScreen<TParams = unknown>(config: ScreenConfig<TParams>): ScreenDefinition<TParams>;

interface ScreenConfig<TParams = unknown> {
  component: ComponentType;
  options?: ScreenOptions | ((props: { route: { params?: TParams }; navigation: unknown }) => ScreenOptions);
  params?: TParams;
  listeners?: {
    focus?: () => void;
    blur?: () => void;
    beforeRemove?: (e: { preventDefault: () => void }) => void;
  };
}

interface ScreenOptions {
  title?: string;
  headerShown?: boolean;
  headerTitle?: string | (() => React.ReactNode);
  headerLeft?: () => React.ReactNode;
  headerRight?: () => React.ReactNode;
  headerStyle?: object;
  headerTitleStyle?: object;
  headerBackTitle?: string;
  headerBackTitleVisible?: boolean;
  presentation?: "card" | "modal" | "transparentModal" | "containedModal" | "fullScreenModal" | "formSheet";
  animation?: "default" | "fade" | "fade_from_bottom" | "flip" | "simple_push" | "slide_from_bottom" | "slide_from_right" | "slide_from_left" | "none";
  gestureEnabled?: boolean;
  gestureDirection?: "horizontal" | "vertical";
  animationDuration?: number;
  // Tab options
  tabBarLabel?: string;
  tabBarIcon?: (props: { focused: boolean; color: string; size: number }) => React.ReactNode;
  tabBarBadge?: string | number;
  // Drawer options
  drawerLabel?: string;
  drawerIcon?: (props: { focused: boolean; color: string; size: number }) => React.ReactNode;
}

function defineLayout<T extends LayoutConfig>(config: T): LayoutDefinition<T>;

type LayoutConfig = StackLayoutConfig | TabsLayoutConfig | DrawerLayoutConfig;

interface StackLayoutConfig {
  type: "stack";
  initialRouteName?: string;
  screenOptions?: StackScreenOptions;
}

interface TabsLayoutConfig {
  type: "tabs";
  initialRouteName?: string;
  screenOptions?: TabScreenOptions;
  tabBar?: ComponentType;
  screens?: Record<string, PerScreenOptions>;
}

interface DrawerLayoutConfig {
  type: "drawer";
  initialRouteName?: string;
  screenOptions?: DrawerScreenOptions;
  drawerContent?: ComponentType;
  screens?: Record<string, PerScreenOptions>;
}

function createParamSchema<T extends ParamSchemaShape>(shape: T): ParamSchema<T>;

import { z } from "zod";

const params = createParamSchema({
  userId: z.string().uuid(),
  tab: z.enum(["profile", "settings"]).optional(),
});

function createTeardownRouter<T extends NavigatorNode | FlatRouteTree>(
  options: TeardownRouterOptions<T>
): ComponentType;

interface TeardownRouterOptions<T> {
  routeTree: T;
  initialRouteName?: string;
  linking?: LinkingOptions<Record<string, unknown>>;
  theme?: Theme;
  notFoundComponent?: ComponentType;
  navigationContainerProps?: Omit<NavigationContainerProps, "children">;
}

import { createTeardownRouter } from "@teardown/navigation";
import { routeTree } from "../.teardown/routeTree.generated";
import { linking } from "../.teardown/linking.generated";

export const Router = createTeardownRouter({
  routeTree,
  linking,
  initialRouteName: "index",
});

function buildUrl<T extends string>(path: T, params?: Record<string, string | number>): string;

buildUrl("/users/:userId", { userId: "123" }); // "/users/123"
buildUrl("/search/:query?", { query: "react" }); // "/search/react"
buildUrl("/search/:query?"); // "/search"

function matchPath(pattern: string, path: string): MatchResult | null;

interface MatchResult {
  params: Record<string, string>;
  path: string;
}

function parsePath(path: string): ParsedPath;

interface ParsedPath {
  segments: string[];
  params: Record<string, string>;
}

function pathToScreenName(path: string): string;

pathToScreenName("/users/:userId"); // "users/[userId]"
pathToScreenName("/"); // "index"

type ParamsFor<T extends RegisteredRoutePath> = RegisteredRouteParams[T];

type RegisteredRoutePath = keyof RegisteredRouteParams;

type InferParams<T extends string> = /* inferred param object type */;

type Params = InferParams<"/users/:userId/posts/:postId">;
// { userId: string; postId: string }

function withTeardownNavigation(
  config: MetroConfig,
  options?: TeardownNavigationOptions
): MetroConfig;

interface TeardownNavigationOptions {
  routesDir?: string;      // Default: "./src/_routes"
  generatedDir?: string;   // Default: "./.teardown"
  prefixes?: string[];     // Default: []
  verbose?: boolean;       // Default: false
  autoTemplate?: boolean;  // Default: true
  usePolling?: boolean;    // Default: false
}

class Generator {
  constructor(config: GeneratorConfig);
  run(event: GeneratorEvent): Promise<void>;
}

function startRouteWatcher(options: WatcherOptions): void;

function stopRouteWatcher(): void;