@teardown/navigation-metro 2.0.43

package/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@teardown/navigation-metro",
+	"version": "2.0.43",
+	"description": "Metro plugin for @teardown/navigation type generation",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"main": "./src/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts",
+			"default": "./src/index.ts"
+		}
+	},
+	"files": [
+		"src/**/*"
+	],
+	"scripts": {
+		"typecheck": "bun x tsgo --noEmit",
+		"lint": "bun x biome lint --write ./src",
+		"fmt": "bun x biome format --write ./src",
+		"check": "bun x biome check ./src",
+		"test": "bun test"
+	},
+	"dependencies": {
+		"chokidar": "^4.0.0",
+		"glob": "^11.0.0"
+	},
+	"peerDependencies": {
+		"metro-config": ">=0.76.0"
+	},
+	"peerDependenciesMeta": {
+		"metro-config": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.3.11",
+		"@teardown/tsconfig": "2.0.43",
+		"@types/node": "24.10.1",
+		"typescript": "5.9.3"
+	}
+}

package/src/generator/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Generator module for @teardown/navigation-metro
+ */
+
+export {
+	buildRouteParamsInterface,
+	type GenerateOptions,
+	generateAllRouteFiles,
+	generateLinkingFileContent,
+	generateRegisterFileContent,
+	generateRoutesFileContent,
+	type RouteParamEntry,
+} from "./route-generator";

package/src/generator/route-generator.test.ts

@@ -0,0 +1,287 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { scanRoutesDirectory } from "../scanner/file-scanner";
+import {
+	buildRouteParamsInterface,
+	generateAllRouteFiles,
+	generateLinkingFileContent,
+	generateRegisterFileContent,
+	generateRoutesFileContent,
+} from "./route-generator";
+
+const TEST_ROUTES_DIR = join(import.meta.dir, "__test_routes__");
+const TEST_GENERATED_DIR = join(import.meta.dir, "__test_generated__");
+
+function createTestFile(relativePath: string, content = "export default {}") {
+	const fullPath = join(TEST_ROUTES_DIR, relativePath);
+	const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(fullPath, content);
+}
+
+describe("Route Generator", () => {
+	beforeEach(() => {
+		mkdirSync(TEST_ROUTES_DIR, { recursive: true });
+		mkdirSync(TEST_GENERATED_DIR, { recursive: true });
+	});
+
+	afterEach(() => {
+		rmSync(TEST_ROUTES_DIR, { recursive: true, force: true });
+		rmSync(TEST_GENERATED_DIR, { recursive: true, force: true });
+	});
+
+	describe("buildRouteParamsInterface", () => {
+		it("should return empty array for empty routes", () => {
+			const result = buildRouteParamsInterface([]);
+			expect(result).toEqual([]);
+		});
+
+		it("should generate static route with undefined params", () => {
+			createTestFile("about.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const result = buildRouteParamsInterface(routes);
+			expect(result).toEqual([{ path: "/about", params: [] }]);
+		});
+
+		it("should generate dynamic route with params", () => {
+			createTestFile("users/[userId].tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const result = buildRouteParamsInterface(routes);
+			const userRoute = result.find((r) => r.path === "/users/:userId");
+			expect(userRoute).toBeDefined();
+			expect(userRoute?.params).toEqual([{ name: "userId", isOptional: false, isCatchAll: false }]);
+		});
+
+		it("should handle optional params", () => {
+			createTestFile("settings/[section]?.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const result = buildRouteParamsInterface(routes);
+			const settingsRoute = result.find((r) => r.path === "/settings/:section?");
+			expect(settingsRoute).toBeDefined();
+			expect(settingsRoute?.params).toEqual([{ name: "section", isOptional: true, isCatchAll: false }]);
+		});
+
+		it("should handle catch-all params", () => {
+			createTestFile("[...slug].tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const result = buildRouteParamsInterface(routes);
+			const catchAllRoute = result.find((r) => r.path === "/*");
+			expect(catchAllRoute).toBeDefined();
+			expect(catchAllRoute?.params).toEqual([{ name: "slug", isOptional: false, isCatchAll: true }]);
+		});
+
+		it("should accumulate params from parent layouts", () => {
+			createTestFile("users/_layout.tsx");
+			createTestFile("users/[userId]/_layout.tsx");
+			createTestFile("users/[userId]/posts/[postId].tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const result = buildRouteParamsInterface(routes);
+			const postRoute = result.find((r) => r.path === "/users/:userId/posts/:postId");
+			expect(postRoute).toBeDefined();
+			expect(postRoute?.params.length).toBe(2);
+			expect(postRoute?.params.map((p) => p.name)).toContain("userId");
+			expect(postRoute?.params.map((p) => p.name)).toContain("postId");
+		});
+
+		it("should skip layout files from route entries", () => {
+			createTestFile("_layout.tsx");
+			createTestFile("index.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const result = buildRouteParamsInterface(routes);
+			// Should only have index, not layout
+			expect(result.length).toBe(1);
+			expect(result[0].path).toBe("/");
+		});
+	});
+
+	describe("generateRoutesFileContent", () => {
+		it("should generate valid TypeScript for static routes", () => {
+			createTestFile("index.tsx");
+			createTestFile("about.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateRoutesFileContent(routes);
+
+			expect(content).toContain("export interface RouteParams");
+			expect(content).toContain('"/": undefined');
+			expect(content).toContain('"/about": undefined');
+			expect(content).toContain("export type RoutePath = keyof RouteParams");
+			expect(content).toContain("export type ParamsFor<T extends RoutePath> = RouteParams[T]");
+		});
+
+		it("should generate valid TypeScript for dynamic routes", () => {
+			createTestFile("users/[userId].tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateRoutesFileContent(routes);
+
+			expect(content).toContain('"/users/:userId": { userId: string }');
+		});
+
+		it("should generate valid TypeScript for optional params", () => {
+			createTestFile("settings/[section]?.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateRoutesFileContent(routes);
+
+			expect(content).toContain('"/settings/:section?": { section?: string }');
+		});
+
+		it("should generate valid TypeScript for catch-all routes", () => {
+			createTestFile("[...slug].tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateRoutesFileContent(routes);
+
+			expect(content).toContain('"/*": { slug: string[] }');
+		});
+
+		it("should include RouteWithParams utility type", () => {
+			createTestFile("index.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateRoutesFileContent(routes);
+
+			expect(content).toContain("export type RouteWithParams");
+		});
+
+		it("should include NavigatorType", () => {
+			createTestFile("index.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateRoutesFileContent(routes);
+
+			expect(content).toContain('export type NavigatorType = "stack" | "tabs" | "drawer"');
+		});
+	});
+
+	describe("generateLinkingFileContent", () => {
+		it("should generate linking config for static routes", () => {
+			createTestFile("index.tsx");
+			createTestFile("about.tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateLinkingFileContent(routes, ["myapp://"]);
+
+			expect(content).toContain("export const generatedLinkingConfig");
+			expect(content).toContain('"myapp://"');
+		});
+
+		it("should convert dynamic params to react-navigation format", () => {
+			createTestFile("users/[userId].tsx");
+			const { routes } = scanRoutesDirectory(TEST_ROUTES_DIR);
+
+			const content = generateLinkingFileContent(routes, []);
+
+			// Should have :userId format for react-navigation
+			expect(content).toContain('"/users/:userId"');
+		});
+	});
+
+	describe("generateRegisterFileContent", () => {
+		it("should generate module augmentation", () => {
+			const content = generateRegisterFileContent();
+
+			expect(content).toContain("declare module '@teardown/navigation'");
+			expect(content).toContain("interface Register");
+			expect(content).toContain("routeParams: RouteParams");
+			expect(content).toContain("routePath: RoutePath");
+		});
+	});
+
+	describe("generateAllRouteFiles", () => {
+		it("should create generated directory if not exists", () => {
+			rmSync(TEST_GENERATED_DIR, { recursive: true, force: true });
+			createTestFile("index.tsx");
+
+			generateAllRouteFiles({
+				routesDir: TEST_ROUTES_DIR,
+				generatedDir: TEST_GENERATED_DIR,
+				prefixes: [],
+				verbose: false,
+			});
+
+			expect(existsSync(TEST_GENERATED_DIR)).toBe(true);
+		});
+
+		it("should generate routes.generated.ts", () => {
+			createTestFile("index.tsx");
+			createTestFile("about.tsx");
+
+			generateAllRouteFiles({
+				routesDir: TEST_ROUTES_DIR,
+				generatedDir: TEST_GENERATED_DIR,
+				prefixes: [],
+				verbose: false,
+			});
+
+			const generatedPath = join(TEST_GENERATED_DIR, "routes.generated.ts");
+			expect(existsSync(generatedPath)).toBe(true);
+
+			const content = readFileSync(generatedPath, "utf-8");
+			expect(content).toContain("RouteParams");
+			expect(content).toContain('"/about"');
+		});
+
+		it("should generate linking.generated.ts", () => {
+			createTestFile("index.tsx");
+
+			generateAllRouteFiles({
+				routesDir: TEST_ROUTES_DIR,
+				generatedDir: TEST_GENERATED_DIR,
+				prefixes: ["myapp://"],
+				verbose: false,
+			});
+
+			const generatedPath = join(TEST_GENERATED_DIR, "linking.generated.ts");
+			expect(existsSync(generatedPath)).toBe(true);
+
+			const content = readFileSync(generatedPath, "utf-8");
+			expect(content).toContain("generatedLinkingConfig");
+		});
+
+		it("should generate register.d.ts", () => {
+			createTestFile("index.tsx");
+
+			generateAllRouteFiles({
+				routesDir: TEST_ROUTES_DIR,
+				generatedDir: TEST_GENERATED_DIR,
+				prefixes: [],
+				verbose: false,
+			});
+
+			const generatedPath = join(TEST_GENERATED_DIR, "register.d.ts");
+			expect(existsSync(generatedPath)).toBe(true);
+
+			const content = readFileSync(generatedPath, "utf-8");
+			expect(content).toContain("declare module '@teardown/navigation'");
+		});
+
+		it("should generate manifest.json", () => {
+			createTestFile("index.tsx");
+			createTestFile("users/[userId].tsx");
+
+			generateAllRouteFiles({
+				routesDir: TEST_ROUTES_DIR,
+				generatedDir: TEST_GENERATED_DIR,
+				prefixes: [],
+				verbose: false,
+			});
+
+			const generatedPath = join(TEST_GENERATED_DIR, "manifest.json");
+			expect(existsSync(generatedPath)).toBe(true);
+
+			const content = JSON.parse(readFileSync(generatedPath, "utf-8"));
+			expect(content.routeCount).toBe(2);
+			expect(content.routes).toBeInstanceOf(Array);
+			expect(content.generatedAt).toBeDefined();
+		});
+	});
+});

package/src/generator/route-generator.ts

@@ -0,0 +1,231 @@
+/**
+ * Route generator for @teardown/navigation-metro
+ * Generates TypeScript type definitions from scanned route tree
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { flattenRoutes, type ParamDefinition, type RouteNode, scanRoutesDirectory } from "../scanner/file-scanner";
+
+export interface GenerateOptions {
+	routesDir: string;
+	generatedDir: string;
+	prefixes: string[];
+	verbose: boolean;
+}
+
+export interface RouteParamEntry {
+	path: string;
+	params: ParamDefinition[];
+}
+
+/**
+ * Generates all route files (routes.generated.ts, linking.generated.ts, register.d.ts, manifest.json)
+ */
+export function generateAllRouteFiles(options: GenerateOptions): void {
+	const { routesDir, generatedDir, prefixes, verbose } = options;
+
+	// Ensure generated directory exists
+	mkdirSync(generatedDir, { recursive: true });
+
+	// Scan routes
+	const { routes, errors } = scanRoutesDirectory(routesDir);
+
+	if (errors.length > 0 && verbose) {
+		console.warn("[teardown/navigation] Scan warnings:", errors);
+	}
+
+	// Generate files
+	const routesContent = generateRoutesFileContent(routes);
+	writeFileSync(join(generatedDir, "routes.generated.ts"), routesContent);
+
+	const linkingContent = generateLinkingFileContent(routes, prefixes);
+	writeFileSync(join(generatedDir, "linking.generated.ts"), linkingContent);
+
+	const registerContent = generateRegisterFileContent();
+	writeFileSync(join(generatedDir, "register.d.ts"), registerContent);
+
+	const manifestContent = generateManifestContent(routes);
+	writeFileSync(join(generatedDir, "manifest.json"), JSON.stringify(manifestContent, null, 2));
+
+	if (verbose) {
+		const count = countRoutes(routes);
+		console.log(`[teardown/navigation] Generated ${count} routes`);
+	}
+}
+
+/**
+ * Builds the RouteParams interface entries from the route tree
+ * Each route has all its params extracted from its full path, so no accumulation needed
+ */
+export function buildRouteParamsInterface(routes: RouteNode[]): RouteParamEntry[] {
+	const result: RouteParamEntry[] = [];
+
+	function traverse(nodes: RouteNode[]): void {
+		for (const node of nodes) {
+			if (node.isLayout) {
+				// Layouts don't get their own route entry
+				traverse(node.children);
+				continue;
+			}
+
+			result.push({
+				path: node.path,
+				params: node.params,
+			});
+
+			if (node.children.length > 0) {
+				traverse(node.children);
+			}
+		}
+	}
+
+	traverse(routes);
+	return result;
+}
+
+/**
+ * Generates the routes.generated.ts file content
+ */
+export function generateRoutesFileContent(routes: RouteNode[]): string {
+	const routeParams = buildRouteParamsInterface(routes);
+
+	const lines: string[] = [
+		"// Auto-generated by @teardown/navigation",
+		"// Do not edit this file directly",
+		`// Generated at: ${new Date().toISOString()}`,
+		"",
+		"export interface RouteParams {",
+	];
+
+	// Add route param entries
+	for (const { path, params } of routeParams) {
+		const paramsType =
+			params.length === 0
+				? "undefined"
+				: `{ ${params
+						.map((p) => {
+							const type = p.isCatchAll ? "string[]" : "string";
+							return `${p.name}${p.isOptional ? "?" : ""}: ${type}`;
+						})
+						.join("; ")} }`;
+
+		lines.push(`\t"${path}": ${paramsType};`);
+	}
+
+	lines.push("}");
+	lines.push("");
+
+	// Add type aliases
+	lines.push("export type RoutePath = keyof RouteParams;");
+	lines.push("");
+	lines.push("export type ParamsFor<T extends RoutePath> = RouteParams[T];");
+	lines.push("");
+
+	// Add RouteWithParams utility type
+	lines.push("export type RouteWithParams = {");
+	lines.push("\t[K in RoutePath]: RouteParams[K] extends undefined");
+	lines.push("\t\t? { path: K }");
+	lines.push("\t\t: { path: K; params: RouteParams[K] };");
+	lines.push("}[RoutePath];");
+	lines.push("");
+
+	// Add NavigatorType
+	lines.push('export type NavigatorType = "stack" | "tabs" | "drawer";');
+	lines.push("");
+
+	return lines.join("\n");
+}
+
+/**
+ * Generates the linking.generated.ts file content
+ */
+export function generateLinkingFileContent(routes: RouteNode[], prefixes: string[]): string {
+	const routeParams = buildRouteParamsInterface(routes);
+
+	const lines: string[] = [
+		"// Auto-generated by @teardown/navigation",
+		'import type { LinkingOptions } from "@react-navigation/native";',
+		'import type { RouteParams } from "./routes.generated";',
+		"",
+	];
+
+	// Build screens config
+	const screens: Record<string, string> = {};
+	for (const { path } of routeParams) {
+		// Convert /users/:userId to users/:userId (remove leading slash)
+		const linkingPath = path === "/" ? "" : path.slice(1);
+		screens[path] = linkingPath;
+	}
+
+	lines.push('export const generatedLinkingConfig: LinkingOptions<RouteParams>["config"] = {');
+	lines.push("\tscreens: {");
+
+	for (const [routePath, linkingPath] of Object.entries(screens)) {
+		lines.push(`\t\t"${routePath}": "${linkingPath}",`);
+	}
+
+	lines.push("\t},");
+	lines.push("};");
+	lines.push("");
+
+	// Add prefixes
+	lines.push(`export const defaultPrefixes: string[] = ${JSON.stringify(prefixes)};`);
+	lines.push("");
+
+	return lines.join("\n");
+}
+
+/**
+ * Generates the register.d.ts file content
+ */
+export function generateRegisterFileContent(): string {
+	const lines: string[] = [
+		"// Auto-generated by @teardown/navigation",
+		'import type { RouteParams, RoutePath } from "./routes.generated";',
+		"",
+		"declare module '@teardown/navigation' {",
+		"\tinterface Register {",
+		"\t\trouteParams: RouteParams;",
+		"\t\troutePath: RoutePath;",
+		"\t}",
+		"}",
+		"",
+	];
+
+	return lines.join("\n");
+}
+
+/**
+ * Generates the manifest.json content
+ */
+function generateManifestContent(routes: RouteNode[]): {
+	generatedAt: string;
+	routeCount: number;
+	routes: Array<{
+		path: string;
+		file: string;
+		params: ParamDefinition[];
+		layoutType: string;
+	}>;
+} {
+	const allRoutes = flattenRoutes(routes);
+
+	return {
+		generatedAt: new Date().toISOString(),
+		routeCount: allRoutes.filter((r) => !r.isLayout).length,
+		routes: allRoutes.map((r) => ({
+			path: r.path,
+			file: r.relativePath,
+			params: r.params,
+			layoutType: r.layoutType,
+		})),
+	};
+}
+
+/**
+ * Counts the number of non-layout routes
+ */
+function countRoutes(routes: RouteNode[]): number {
+	return flattenRoutes(routes).filter((r) => !r.isLayout).length;
+}