@teardown/navigation-metro 2.0.43

package/src/validator/route-validator.ts

@@ -0,0 +1,178 @@
+/**
+ * Route validator for @teardown/navigation-metro
+ * Validates route files for common issues and best practices
+ */
+
+import { readFileSync } from "node:fs";
+import { flattenRoutes, type RouteNode, scanRoutesDirectory } from "../scanner/file-scanner";
+
+export interface ValidationError {
+	file: string;
+	message: string;
+	severity: "error" | "warning";
+	line?: number;
+}
+
+/**
+ * Validates all routes in a directory
+ */
+export function validateRoutes(routesDir: string): ValidationError[] {
+	const errors: ValidationError[] = [];
+	const { routes, errors: scanErrors } = scanRoutesDirectory(routesDir);
+
+	// Add scan errors
+	errors.push(
+		...scanErrors.map((e) => ({
+			file: e.file,
+			message: e.message,
+			severity: "error" as const,
+		}))
+	);
+
+	// If the directory doesn't exist, we already have an error
+	if (scanErrors.length > 0 && routes.length === 0) {
+		return errors;
+	}
+
+	// Flatten routes for validation
+	const flatRoutes = flattenRoutes(routes);
+	const seenPaths = new Map<string, string>();
+
+	for (const route of flatRoutes) {
+		// Skip layout files for path uniqueness check
+		if (route.isLayout) {
+			validateLayoutFile(route, errors);
+			continue;
+		}
+
+		// Check for duplicate paths
+		if (seenPaths.has(route.path)) {
+			errors.push({
+				file: route.filePath,
+				message: `Duplicate route path "${route.path}" (also defined in ${seenPaths.get(route.path)})`,
+				severity: "error",
+			});
+		} else {
+			seenPaths.set(route.path, route.filePath);
+		}
+
+		// Validate screen file
+		validateScreenFile(route, errors);
+	}
+
+	return errors;
+}
+
+/**
+ * Validates a screen file
+ */
+function validateScreenFile(route: RouteNode, errors: ValidationError[]): void {
+	const content = safeReadFile(route.filePath);
+	if (content === null) {
+		errors.push({
+			file: route.filePath,
+			message: "Could not read route file",
+			severity: "error",
+		});
+		return;
+	}
+
+	// Check for default export
+	if (!hasDefaultExport(content)) {
+		errors.push({
+			file: route.filePath,
+			message: "Route file must have a default export",
+			severity: "error",
+		});
+	}
+
+	// Check for defineScreen usage
+	if (!usesDefineScreen(content)) {
+		errors.push({
+			file: route.filePath,
+			message: "Screen should use defineScreen() for proper typing",
+			severity: "warning",
+		});
+	}
+
+	// Check dynamic routes have param schema
+	if (route.params.length > 0 && !hasParamSchema(content)) {
+		errors.push({
+			file: route.filePath,
+			message: "Dynamic route should export a params schema for runtime validation",
+			severity: "warning",
+		});
+	}
+}
+
+/**
+ * Validates a layout file
+ */
+function validateLayoutFile(route: RouteNode, errors: ValidationError[]): void {
+	const content = safeReadFile(route.filePath);
+	if (content === null) {
+		errors.push({
+			file: route.filePath,
+			message: "Could not read layout file",
+			severity: "error",
+		});
+		return;
+	}
+
+	// Check for default export
+	if (!hasDefaultExport(content)) {
+		errors.push({
+			file: route.filePath,
+			message: "Layout file must have a default export",
+			severity: "error",
+		});
+	}
+
+	// Check for defineLayout usage
+	if (!usesDefineLayout(content)) {
+		errors.push({
+			file: route.filePath,
+			message: "Layout file should use defineLayout() for proper configuration",
+			severity: "warning",
+		});
+	}
+}
+
+/**
+ * Safely reads a file, returning null on error
+ */
+function safeReadFile(filePath: string): string | null {
+	try {
+		return readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Checks if file has a default export
+ */
+function hasDefaultExport(content: string): boolean {
+	return content.includes("export default");
+}
+
+/**
+ * Checks if file uses defineScreen
+ */
+function usesDefineScreen(content: string): boolean {
+	return content.includes("defineScreen");
+}
+
+/**
+ * Checks if file uses defineLayout
+ */
+function usesDefineLayout(content: string): boolean {
+	return content.includes("defineLayout");
+}
+
+/**
+ * Checks if file has a param schema
+ */
+function hasParamSchema(content: string): boolean {
+	return content.includes("paramsSchema") || content.includes("createParamSchema");
+}

package/src/watcher/file-watcher.ts

@@ -0,0 +1,132 @@
+/**
+ * File watcher for @teardown/navigation-metro
+ * Watches route files and triggers regeneration on changes
+ */
+
+import { join, relative } from "node:path";
+import { type FSWatcher, watch } from "chokidar";
+import { generateAllRouteFiles } from "../generator/route-generator";
+import { type ValidationError, validateRoutes } from "../validator/route-validator";
+
+export interface WatcherOptions {
+	routesDir: string;
+	generatedDir: string;
+	prefixes: string[];
+	verbose: boolean;
+	onRegenerate?: () => void;
+	onError?: (errors: ValidationError[]) => void;
+}
+
+let watcherInstance: FSWatcher | null = null;
+
+/**
+ * Starts watching the routes directory for changes
+ * Returns a cleanup function to stop watching
+ */
+export function startRouteWatcher(options: WatcherOptions): () => void {
+	const { routesDir, generatedDir, prefixes, verbose, onRegenerate, onError } = options;
+
+	// Close existing watcher if any
+	if (watcherInstance) {
+		watcherInstance.close();
+	}
+
+	const watcher = watch(join(routesDir, "**/*.{ts,tsx}"), {
+		ignoreInitial: true,
+		ignored: [
+			/(^|[/\\])\../, // Dotfiles
+			/node_modules/,
+			/\.test\./,
+			/\.spec\./,
+		],
+	});
+
+	let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+
+	const regenerate = () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+		}
+
+		// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: debounced validate + generate
+		debounceTimer = setTimeout(() => {
+			try {
+				// Validate first
+				const errors = validateRoutes(routesDir);
+				const hasErrors = errors.some((e) => e.severity === "error");
+
+				if (hasErrors) {
+					if (verbose) {
+						console.error("[teardown/navigation] Validation errors:");
+						for (const e of errors.filter((err) => err.severity === "error")) {
+							console.error(`  ${e.file}: ${e.message}`);
+						}
+					}
+					onError?.(errors);
+					return;
+				}
+
+				// Generate if validation passes
+				generateAllRouteFiles({ routesDir, generatedDir, prefixes, verbose });
+
+				if (verbose) {
+					console.log("[teardown/navigation] Routes regenerated");
+				}
+
+				onRegenerate?.();
+			} catch (error) {
+				if (verbose) {
+					console.error("[teardown/navigation] Generation failed:", error);
+				}
+			}
+		}, 100);
+	};
+
+	watcher.on("add", (filePath) => {
+		if (verbose) {
+			console.log(`[teardown/navigation] File added: ${relative(routesDir, filePath)}`);
+		}
+		regenerate();
+	});
+
+	watcher.on("unlink", (filePath) => {
+		if (verbose) {
+			console.log(`[teardown/navigation] File removed: ${relative(routesDir, filePath)}`);
+		}
+		regenerate();
+	});
+
+	watcher.on("change", (filePath) => {
+		if (verbose) {
+			console.log(`[teardown/navigation] File changed: ${relative(routesDir, filePath)}`);
+		}
+		regenerate();
+	});
+
+	watcherInstance = watcher;
+
+	return () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+		}
+		watcher.close();
+		watcherInstance = null;
+	};
+}
+
+/**
+ * Stops the route watcher if it's running
+ */
+export function stopRouteWatcher(): void {
+	if (watcherInstance) {
+		watcherInstance.close();
+		watcherInstance = null;
+	}
+}
+
+/**
+ * Checks if the watcher is currently running
+ */
+export function isWatcherRunning(): boolean {
+	return watcherInstance !== null;
+}

package/src/watcher/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Watcher module for @teardown/navigation-metro
+ */
+
+export { isWatcherRunning, startRouteWatcher, stopRouteWatcher, type WatcherOptions } from "./file-watcher";