@teardown/navigation-metro 2.0.53 → 2.0.57

package/src/scanner/file-scanner.test.ts

@@ -1,271 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { buildUrlPath, extractParams, filePathToScreenName, type RouteNode, scanRoutesDirectory } from "./file-scanner";
-
-const TEST_DIR = join(import.meta.dir, "__test_routes__");
-
-function createTestFile(relativePath: string, content = "export default {}") {
-	const fullPath = join(TEST_DIR, relativePath);
-	const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-	mkdirSync(dir, { recursive: true });
-	writeFileSync(fullPath, content);
-}
-
-describe("File Scanner", () => {
-	beforeEach(() => {
-		mkdirSync(TEST_DIR, { recursive: true });
-	});
-
-	afterEach(() => {
-		rmSync(TEST_DIR, { recursive: true, force: true });
-	});
-
-	describe("extractParams", () => {
-		it("should extract required param from [param]", () => {
-			const params = extractParams("[userId]");
-			expect(params).toEqual([{ name: "userId", isOptional: false, isCatchAll: false }]);
-		});
-
-		it("should extract optional param from [param]?", () => {
-			const params = extractParams("[section]?");
-			expect(params).toEqual([{ name: "section", isOptional: true, isCatchAll: false }]);
-		});
-
-		it("should extract catch-all param from [...slug]", () => {
-			const params = extractParams("[...slug]");
-			expect(params).toEqual([{ name: "slug", isOptional: false, isCatchAll: true }]);
-		});
-
-		it("should return empty array for static filename", () => {
-			const params = extractParams("about");
-			expect(params).toEqual([]);
-		});
-
-		it("should return empty array for index", () => {
-			const params = extractParams("index");
-			expect(params).toEqual([]);
-		});
-
-		it("should return empty array for _layout", () => {
-			const params = extractParams("_layout");
-			expect(params).toEqual([]);
-		});
-	});
-
-	describe("buildUrlPath", () => {
-		it("should build root path for index.tsx", () => {
-			const path = buildUrlPath("index.tsx", true, false);
-			expect(path).toBe("/");
-		});
-
-		it("should build static path", () => {
-			const path = buildUrlPath("about.tsx", false, false);
-			expect(path).toBe("/about");
-		});
-
-		it("should build nested path", () => {
-			const path = buildUrlPath("users/index.tsx", true, false);
-			expect(path).toBe("/users");
-		});
-
-		it("should build dynamic path with required param", () => {
-			const path = buildUrlPath("users/[userId].tsx", false, false);
-			expect(path).toBe("/users/:userId");
-		});
-
-		it("should build dynamic path with optional param", () => {
-			const path = buildUrlPath("settings/[section]?.tsx", false, false);
-			expect(path).toBe("/settings/:section?");
-		});
-
-		it("should build catch-all path", () => {
-			const path = buildUrlPath("docs/[...slug].tsx", false, false);
-			expect(path).toBe("/docs/*");
-		});
-
-		it("should remove route groups from path", () => {
-			const path = buildUrlPath("(tabs)/home.tsx", false, false);
-			expect(path).toBe("/home");
-		});
-
-		it("should return empty string for layout files", () => {
-			const path = buildUrlPath("_layout.tsx", false, true);
-			expect(path).toBe("");
-		});
-
-		it("should handle deeply nested dynamic paths", () => {
-			const path = buildUrlPath("users/[userId]/posts/[postId].tsx", false, false);
-			expect(path).toBe("/users/:userId/posts/:postId");
-		});
-	});
-
-	describe("filePathToScreenName", () => {
-		it("should convert file path to screen name", () => {
-			expect(filePathToScreenName("users/[userId].tsx")).toBe("users/[userId]");
-		});
-
-		it("should handle index files", () => {
-			expect(filePathToScreenName("users/index.tsx")).toBe("users/index");
-		});
-
-		it("should handle layout files", () => {
-			expect(filePathToScreenName("users/_layout.tsx")).toBe("users/_layout");
-		});
-	});
-
-	describe("scanRoutesDirectory", () => {
-		it("should return empty routes for non-existent directory", () => {
-			const result = scanRoutesDirectory("/non/existent/path");
-			expect(result.routes).toEqual([]);
-			expect(result.errors.length).toBeGreaterThan(0);
-		});
-
-		it("should scan single index file", () => {
-			createTestFile("index.tsx", "export default function Home() { return null; }");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			expect(result.errors).toEqual([]);
-			expect(result.routes.length).toBe(1);
-			expect(result.routes[0].path).toBe("/");
-			expect(result.routes[0].isIndex).toBe(true);
-		});
-
-		it("should scan static route file", () => {
-			createTestFile("about.tsx", "export default function About() { return null; }");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			expect(result.routes.length).toBe(1);
-			expect(result.routes[0].path).toBe("/about");
-			expect(result.routes[0].isIndex).toBe(false);
-		});
-
-		it("should scan dynamic route file", () => {
-			createTestFile("users/[userId].tsx", "export default function User() { return null; }");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			const userRoute = result.routes.find((r) => r.path === "/users/:userId");
-			expect(userRoute).toBeDefined();
-			expect(userRoute?.params).toEqual([{ name: "userId", isOptional: false, isCatchAll: false }]);
-		});
-
-		it("should scan layout files", () => {
-			createTestFile("_layout.tsx", "export default { type: 'stack' }");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			expect(result.routes.length).toBe(1);
-			expect(result.routes[0].isLayout).toBe(true);
-			expect(result.routes[0].layoutType).toBe("stack");
-		});
-
-		it("should scan tab layout files", () => {
-			createTestFile(
-				"(tabs)/_layout.tsx",
-				`
-        import { defineLayout } from '@teardown/navigation';
-        export default defineLayout({ type: 'tabs' });
-      `
-			);
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			const tabLayout = result.routes.find((r) => r.isLayout && r.groupName === "tabs");
-			expect(tabLayout).toBeDefined();
-			expect(tabLayout?.layoutType).toBe("tabs");
-		});
-
-		it("should detect route groups", () => {
-			createTestFile("(auth)/login.tsx", "export default function Login() { return null; }");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			const loginRoute = result.routes.find((r) => r.path === "/login");
-			expect(loginRoute).toBeDefined();
-			expect(loginRoute?.groupName).toBe("auth");
-		});
-
-		it("should ignore hidden files starting with underscore (except _layout)", () => {
-			createTestFile("_hidden.tsx", "export default {}");
-			createTestFile("about.tsx", "export default {}");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			expect(result.routes.length).toBe(1);
-			expect(result.routes[0].path).toBe("/about");
-		});
-
-		it("should ignore test files", () => {
-			createTestFile("about.test.tsx", "export default {}");
-			createTestFile("about.tsx", "export default {}");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			expect(result.routes.length).toBe(1);
-			expect(result.routes[0].path).toBe("/about");
-		});
-
-		it("should scan catch-all routes", () => {
-			createTestFile("[...catchAll].tsx", "export default function CatchAll() { return null; }");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-			expect(result.routes.length).toBe(1);
-			expect(result.routes[0].path).toBe("/*");
-			expect(result.routes[0].isCatchAll).toBe(true);
-			expect(result.routes[0].params).toEqual([{ name: "catchAll", isOptional: false, isCatchAll: true }]);
-		});
-
-		it("should build route tree with parent-child relationships", () => {
-			createTestFile("users/_layout.tsx", "export default { type: 'stack' }");
-			createTestFile("users/index.tsx", "export default {}");
-			createTestFile("users/[userId].tsx", "export default {}");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-
-			// Find the layout
-			const layout = result.routes.find((r) => r.isLayout && r.relativePath.includes("users"));
-			expect(layout).toBeDefined();
-			expect(layout?.children.length).toBe(2);
-
-			// Children should be index and [userId]
-			const childPaths = layout?.children.map((c) => c.path) || [];
-			expect(childPaths).toContain("/users");
-			expect(childPaths).toContain("/users/:userId");
-		});
-
-		it("should handle complex nested structure", () => {
-			createTestFile("_layout.tsx", "export default { type: 'stack' }");
-			createTestFile("index.tsx", "export default {}");
-			createTestFile("about.tsx", "export default {}");
-			createTestFile("users/_layout.tsx", "export default { type: 'stack' }");
-			createTestFile("users/index.tsx", "export default {}");
-			createTestFile("users/[userId].tsx", "export default {}");
-			createTestFile("users/[userId]/posts/[postId].tsx", "export default {}");
-			createTestFile("(tabs)/_layout.tsx", "export default { type: 'tabs' }");
-			createTestFile("(tabs)/home.tsx", "export default {}");
-			createTestFile("(tabs)/settings.tsx", "export default {}");
-
-			const result = scanRoutesDirectory(TEST_DIR);
-
-			// Should have root layout with children
-			const rootLayout = result.routes.find((r) => r.isLayout && r.relativePath === "_layout.tsx");
-			expect(rootLayout).toBeDefined();
-
-			// Flatten all routes for easier checking
-			const allRoutes = flattenRoutes(result.routes);
-			const allPaths = allRoutes.filter((r) => !r.isLayout).map((r) => r.path);
-
-			expect(allPaths).toContain("/");
-			expect(allPaths).toContain("/about");
-			expect(allPaths).toContain("/users");
-			expect(allPaths).toContain("/users/:userId");
-			expect(allPaths).toContain("/users/:userId/posts/:postId");
-			expect(allPaths).toContain("/home");
-			expect(allPaths).toContain("/settings");
-		});
-	});
-});
-
-function flattenRoutes(routes: RouteNode[]): RouteNode[] {
-	const result: RouteNode[] = [];
-	for (const route of routes) {
-		result.push(route);
-		result.push(...flattenRoutes(route.children));
-	}
-	return result;
-}

package/src/scanner/file-scanner.ts

@@ -1,329 +0,0 @@
-/**
- * File scanner for @teardown/navigation-metro
- * Scans routes directory and builds a route tree for type generation
- */
-
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { basename, dirname, extname, join } from "node:path";
-
-export interface RouteNode {
-	/** Screen name derived from file path */
-	name: string;
-	/** URL path for this route */
-	path: string;
-	/** Absolute file path */
-	filePath: string;
-	/** Relative file path from routes dir */
-	relativePath: string;
-	/** Extracted dynamic params */
-	params: ParamDefinition[];
-	/** Child routes */
-	children: RouteNode[];
-	/** Navigator type from _layout.tsx */
-	layoutType: "stack" | "tabs" | "drawer" | "none";
-	/** Is this an index route */
-	isIndex: boolean;
-	/** Is this a layout file */
-	isLayout: boolean;
-	/** Is this a catch-all route */
-	isCatchAll: boolean;
-	/** Route group name (from parentheses) */
-	groupName: string | null;
-}
-
-export interface ParamDefinition {
-	name: string;
-	isOptional: boolean;
-	isCatchAll: boolean;
-}
-
-export interface ScanResult {
-	routes: RouteNode[];
-	errors: ScanError[];
-}
-
-export interface ScanError {
-	file: string;
-	message: string;
-}
-
-/**
- * Scans a routes directory and builds a route tree
- */
-export function scanRoutesDirectory(routesDir: string): ScanResult {
-	const errors: ScanError[] = [];
-
-	if (!existsSync(routesDir)) {
-		return {
-			routes: [],
-			errors: [{ file: routesDir, message: "Routes directory does not exist" }],
-		};
-	}
-
-	const files = findRouteFiles(routesDir);
-	const routeNodes = new Map<string, RouteNode>();
-
-	// First pass: create all route nodes
-	for (const file of files) {
-		const absolutePath = join(routesDir, file);
-		const node = parseRouteFile(file, absolutePath);
-
-		if (node) {
-			routeNodes.set(file, node);
-		}
-	}
-
-	// Second pass: build tree structure
-	const rootNodes: RouteNode[] = [];
-
-	for (const [filePath, node] of routeNodes) {
-		const parentPath = findParentLayoutPath(filePath, routeNodes);
-
-		if (parentPath) {
-			const parent = routeNodes.get(parentPath);
-			if (parent) {
-				parent.children.push(node);
-			}
-		} else {
-			rootNodes.push(node);
-		}
-	}
-
-	return { routes: rootNodes, errors };
-}
-
-/**
- * Recursively finds all route files in a directory
- */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: route file discovery branches
-function findRouteFiles(dir: string, prefix = ""): string[] {
-	const results: string[] = [];
-
-	const entries = readdirSync(dir, { withFileTypes: true });
-
-	for (const entry of entries) {
-		const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-
-		if (entry.isDirectory()) {
-			// Skip node_modules and hidden directories (except those in parentheses for groups)
-			if (entry.name === "node_modules" || (entry.name.startsWith(".") && !entry.name.startsWith("("))) {
-				continue;
-			}
-			results.push(...findRouteFiles(join(dir, entry.name), relativePath));
-		} else if (entry.isFile()) {
-			// Only include .ts and .tsx files
-			const ext = extname(entry.name);
-			if (ext !== ".ts" && ext !== ".tsx") {
-				continue;
-			}
-
-			// Skip test files
-			if (entry.name.includes(".test.") || entry.name.includes(".spec.")) {
-				continue;
-			}
-
-			// Skip hidden files (starting with _) except _layout
-			const baseName = basename(entry.name, ext);
-			if (baseName.startsWith("_") && baseName !== "_layout") {
-				continue;
-			}
-
-			results.push(relativePath);
-		}
-	}
-
-	return results;
-}
-
-/**
- * Parses a route file and creates a RouteNode
- */
-function parseRouteFile(relativePath: string, absolutePath: string): RouteNode | null {
-	const ext = extname(relativePath);
-	const fileName = basename(relativePath, ext);
-
-	const isLayout = fileName === "_layout";
-	const isIndex = fileName === "index";
-	const isCatchAll = fileName.startsWith("[...");
-
-	// Extract route group from path
-	const groupMatch = relativePath.match(/\(([^)]+)\)/);
-	const groupName = groupMatch ? groupMatch[1] : null;
-
-	// Parse params from the entire relative path (not just filename)
-	// This extracts params from both directory names and the filename
-	const params = extractParams(relativePath);
-
-	// Build URL path
-	const urlPath = buildUrlPath(relativePath, isIndex, isLayout);
-
-	return {
-		name: filePathToScreenName(relativePath),
-		path: urlPath,
-		filePath: absolutePath,
-		relativePath,
-		params,
-		children: [],
-		layoutType: isLayout ? detectLayoutType(absolutePath) : "none",
-		isIndex,
-		isLayout,
-		isCatchAll,
-		groupName,
-	};
-}
-
-/**
- * Extracts dynamic parameters from a filename
- */
-export function extractParams(fileName: string): ParamDefinition[] {
-	const params: ParamDefinition[] = [];
-	const regex = /\[(?:\.\.\.)?([^\]]+)\]\??/g;
-	let match: RegExpExecArray | null;
-
-	// biome-ignore lint/suspicious/noAssignInExpressions: standard regex iteration pattern
-	while ((match = regex.exec(fileName)) !== null) {
-		const fullMatch = match[0];
-		const paramName = match[1].replace("?", "");
-
-		params.push({
-			name: paramName,
-			isOptional: fullMatch.endsWith("?"),
-			isCatchAll: fullMatch.startsWith("[..."),
-		});
-	}
-
-	return params;
-}
-
-/**
- * Builds a URL path from a relative file path
- */
-export function buildUrlPath(relativePath: string, _isIndex: boolean, isLayout: boolean): string {
-	if (isLayout) return "";
-
-	const ext = extname(relativePath);
-	let urlPath = relativePath
-		.replace(ext, "") // Remove extension
-		.replace(/\\/g, "/") // Normalize path separators
-		.replace(/\(([^)]+)\)\//g, "") // Remove route groups from URL
-		.replace(/\[\.\.\.([^\]]+)\]/g, "*") // Catch-all
-		.replace(/\[([^\]]+)\]\?/g, ":$1?") // Optional params
-		.replace(/\[([^\]]+)\]/g, ":$1"); // Required params
-
-	// Handle index files - remove "index" or trailing "/index"
-	if (urlPath === "index") {
-		return "/";
-	}
-	urlPath = urlPath.replace(/\/index$/, "");
-
-	return `/${urlPath}` || "/";
-}
-
-/**
- * Converts a file path to a screen name
- */
-export function filePathToScreenName(relativePath: string): string {
-	const ext = extname(relativePath);
-	return relativePath.replace(ext, "").replace(/\\/g, "/");
-}
-
-/**
- * Detects the layout type from a _layout.tsx file
- */
-function detectLayoutType(absolutePath: string): "stack" | "tabs" | "drawer" {
-	try {
-		const content = readFileSync(absolutePath, "utf-8");
-
-		if (content.includes("type: 'tabs'") || content.includes('type: "tabs"')) {
-			return "tabs";
-		}
-		if (content.includes("type: 'drawer'") || content.includes('type: "drawer"')) {
-			return "drawer";
-		}
-	} catch {
-		// Default to stack on read error
-	}
-
-	return "stack";
-}
-
-/**
- * Finds the parent layout file path for a given route file
- */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: layout path traversal
-function findParentLayoutPath(filePath: string, routeNodes: Map<string, RouteNode>): string | null {
-	const dir = dirname(filePath);
-	const fileName = basename(filePath);
-	const isLayout = fileName === "_layout.tsx" || fileName === "_layout.ts";
-
-	// For root level files
-	if (dir === ".") {
-		// Check if there's a root _layout.tsx and this file is not the layout itself
-		const rootLayout = "_layout.tsx";
-		if (filePath !== rootLayout && routeNodes.has(rootLayout)) {
-			return rootLayout;
-		}
-		const rootLayoutTs = "_layout.ts";
-		if (filePath !== rootLayoutTs && routeNodes.has(rootLayoutTs)) {
-			return rootLayoutTs;
-		}
-		return null;
-	}
-
-	// For non-layout files, look for _layout in the same directory first
-	if (!isLayout) {
-		const sameDirLayout = `${dir}/_layout.tsx`;
-		const sameDirLayoutTs = `${dir}/_layout.ts`;
-
-		if (routeNodes.has(sameDirLayout)) {
-			return sameDirLayout;
-		}
-		if (routeNodes.has(sameDirLayoutTs)) {
-			return sameDirLayoutTs;
-		}
-	}
-
-	// For layouts, or if no layout in same directory, look in parent directories
-	let parentDir = dirname(dir);
-
-	while (parentDir !== ".") {
-		const layoutPath = `${parentDir}/_layout.tsx`;
-		const layoutPathTs = `${parentDir}/_layout.ts`;
-
-		if (routeNodes.has(layoutPath)) {
-			return layoutPath;
-		}
-		if (routeNodes.has(layoutPathTs)) {
-			return layoutPathTs;
-		}
-
-		parentDir = dirname(parentDir);
-	}
-
-	// Check root level layout
-	if (routeNodes.has("_layout.tsx") && filePath !== "_layout.tsx") {
-		return "_layout.tsx";
-	}
-	if (routeNodes.has("_layout.ts") && filePath !== "_layout.ts") {
-		return "_layout.ts";
-	}
-
-	return null;
-}
-
-/**
- * Flattens a route tree into a flat array
- */
-export function flattenRoutes(routes: RouteNode[]): RouteNode[] {
-	const result: RouteNode[] = [];
-
-	function traverse(nodes: RouteNode[]): void {
-		for (const node of nodes) {
-			result.push(node);
-			traverse(node.children);
-		}
-	}
-
-	traverse(routes);
-	return result;
-}

package/src/scanner/index.ts

@@ -1,15 +0,0 @@
-/**
- * Scanner module for @teardown/navigation-metro
- */
-
-export {
-	buildUrlPath,
-	extractParams,
-	filePathToScreenName,
-	flattenRoutes,
-	type ParamDefinition,
-	type RouteNode,
-	type ScanError,
-	type ScanResult,
-	scanRoutesDirectory,
-} from "./file-scanner";