@teardown/navigation-metro 2.0.52 → 2.0.56

package/dist/scanner/file-scanner.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * File scanner for @teardown/navigation-metro
+ * Scans routes directory and builds a route tree for type generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRoutesDirectory = scanRoutesDirectory;
+exports.extractParams = extractParams;
+exports.buildUrlPath = buildUrlPath;
+exports.filePathToScreenName = filePathToScreenName;
+exports.flattenRoutes = flattenRoutes;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Scans a routes directory and builds a route tree
+ */
+function scanRoutesDirectory(routesDir) {
+    const errors = [];
+    if (!(0, node_fs_1.existsSync)(routesDir)) {
+        return {
+            routes: [],
+            errors: [{ file: routesDir, message: "Routes directory does not exist" }],
+        };
+    }
+    const files = findRouteFiles(routesDir);
+    const routeNodes = new Map();
+    // First pass: create all route nodes
+    for (const file of files) {
+        const absolutePath = (0, node_path_1.join)(routesDir, file);
+        const node = parseRouteFile(file, absolutePath);
+        if (node) {
+            routeNodes.set(file, node);
+        }
+    }
+    // Second pass: build tree structure
+    const rootNodes = [];
+    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, prefix = "") {
+    const results = [];
+    const entries = (0, node_fs_1.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((0, node_path_1.join)(dir, entry.name), relativePath));
+        }
+        else if (entry.isFile()) {
+            // Only include .ts and .tsx files
+            const ext = (0, node_path_1.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 = (0, node_path_1.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, absolutePath) {
+    const ext = (0, node_path_1.extname)(relativePath);
+    const fileName = (0, node_path_1.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
+ */
+function extractParams(fileName) {
+    const params = [];
+    const regex = /\[(?:\.\.\.)?([^\]]+)\]\??/g;
+    let match;
+    // 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
+ */
+function buildUrlPath(relativePath, _isIndex, isLayout) {
+    if (isLayout)
+        return "";
+    const ext = (0, node_path_1.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
+ */
+function filePathToScreenName(relativePath) {
+    const ext = (0, node_path_1.extname)(relativePath);
+    return relativePath.replace(ext, "").replace(/\\/g, "/");
+}
+/**
+ * Detects the layout type from a _layout.tsx file
+ */
+function detectLayoutType(absolutePath) {
+    try {
+        const content = (0, node_fs_1.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, routeNodes) {
+    const dir = (0, node_path_1.dirname)(filePath);
+    const fileName = (0, node_path_1.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 = (0, node_path_1.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 = (0, node_path_1.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
+ */
+function flattenRoutes(routes) {
+    const result = [];
+    function traverse(nodes) {
+        for (const node of nodes) {
+            result.push(node);
+            traverse(node.children);
+        }
+    }
+    traverse(routes);
+    return result;
+}

package/dist/scanner/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scanner module for @teardown/navigation-metro
+ */
+export { buildUrlPath, extractParams, filePathToScreenName, flattenRoutes, type ParamDefinition, type RouteNode, type ScanError, type ScanResult, scanRoutesDirectory, } from "./file-scanner";
+//# sourceMappingURL=index.d.ts.map

package/dist/scanner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scanner/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACN,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,UAAU,EACf,mBAAmB,GACnB,MAAM,gBAAgB,CAAC"}

package/dist/scanner/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Scanner module for @teardown/navigation-metro
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRoutesDirectory = exports.flattenRoutes = exports.filePathToScreenName = exports.extractParams = exports.buildUrlPath = void 0;
+var file_scanner_1 = require("./file-scanner");
+Object.defineProperty(exports, "buildUrlPath", { enumerable: true, get: function () { return file_scanner_1.buildUrlPath; } });
+Object.defineProperty(exports, "extractParams", { enumerable: true, get: function () { return file_scanner_1.extractParams; } });
+Object.defineProperty(exports, "filePathToScreenName", { enumerable: true, get: function () { return file_scanner_1.filePathToScreenName; } });
+Object.defineProperty(exports, "flattenRoutes", { enumerable: true, get: function () { return file_scanner_1.flattenRoutes; } });
+Object.defineProperty(exports, "scanRoutesDirectory", { enumerable: true, get: function () { return file_scanner_1.scanRoutesDirectory; } });

package/{src/validator/index.ts → dist/validator/index.d.ts}

@@ -1,5 +1,5 @@
 /**
  * Validator module for @teardown/navigation-metro
  */
-
 export { type ValidationError, validateRoutes } from "./route-validator";
+//# sourceMappingURL=index.d.ts.map

package/dist/validator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validator/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/validator/index.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Validator module for @teardown/navigation-metro
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoutes = void 0;
+var route_validator_1 = require("./route-validator");
+Object.defineProperty(exports, "validateRoutes", { enumerable: true, get: function () { return route_validator_1.validateRoutes; } });

package/dist/validator/route-validator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Route validator for @teardown/navigation-metro
+ * Validates route files for common issues and best practices
+ */
+export interface ValidationError {
+    file: string;
+    message: string;
+    severity: "error" | "warning";
+    line?: number;
+}
+/**
+ * Validates all routes in a directory
+ */
+export declare function validateRoutes(routesDir: string): ValidationError[];
+//# sourceMappingURL=route-validator.d.ts.map

package/dist/validator/route-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-validator.d.ts","sourceRoot":"","sources":["../../src/validator/route-validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CA6CnE"}

package/dist/validator/route-validator.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Route validator for @teardown/navigation-metro
+ * Validates route files for common issues and best practices
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoutes = validateRoutes;
+const node_fs_1 = require("node:fs");
+const file_scanner_1 = require("../scanner/file-scanner");
+/**
+ * Validates all routes in a directory
+ */
+function validateRoutes(routesDir) {
+    const errors = [];
+    const { routes, errors: scanErrors } = (0, file_scanner_1.scanRoutesDirectory)(routesDir);
+    // Add scan errors
+    errors.push(...scanErrors.map((e) => ({
+        file: e.file,
+        message: e.message,
+        severity: "error",
+    })));
+    // 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 = (0, file_scanner_1.flattenRoutes)(routes);
+    const seenPaths = new Map();
+    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, errors) {
+    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, errors) {
+    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) {
+    try {
+        return (0, node_fs_1.readFileSync)(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Checks if file has a default export
+ */
+function hasDefaultExport(content) {
+    return content.includes("export default");
+}
+/**
+ * Checks if file uses defineScreen
+ */
+function usesDefineScreen(content) {
+    return content.includes("defineScreen");
+}
+/**
+ * Checks if file uses defineLayout
+ */
+function usesDefineLayout(content) {
+    return content.includes("defineLayout");
+}
+/**
+ * Checks if file has a param schema
+ */
+function hasParamSchema(content) {
+    return content.includes("paramsSchema") || content.includes("createParamSchema");
+}

package/dist/watcher/file-watcher.d.ts

@@ -0,0 +1,27 @@
+/**
+ * File watcher for @teardown/navigation-metro
+ * Watches route files and triggers regeneration on changes
+ */
+import { type ValidationError } from "../validator/route-validator";
+export interface WatcherOptions {
+    routesDir: string;
+    generatedDir: string;
+    prefixes: string[];
+    verbose: boolean;
+    onRegenerate?: () => void;
+    onError?: (errors: ValidationError[]) => void;
+}
+/**
+ * Starts watching the routes directory for changes
+ * Returns a cleanup function to stop watching
+ */
+export declare function startRouteWatcher(options: WatcherOptions): () => void;
+/**
+ * Stops the route watcher if it's running
+ */
+export declare function stopRouteWatcher(): void;
+/**
+ * Checks if the watcher is currently running
+ */
+export declare function isWatcherRunning(): boolean;
+//# sourceMappingURL=file-watcher.d.ts.map

package/dist/watcher/file-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-watcher.d.ts","sourceRoot":"","sources":["../../src/watcher/file-watcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,8BAA8B,CAAC;AAEpF,MAAM,WAAW,cAAc;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CAC9C;AAID;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,IAAI,CAyFrE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}

package/dist/watcher/file-watcher.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * File watcher for @teardown/navigation-metro
+ * Watches route files and triggers regeneration on changes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRouteWatcher = startRouteWatcher;
+exports.stopRouteWatcher = stopRouteWatcher;
+exports.isWatcherRunning = isWatcherRunning;
+const node_path_1 = require("node:path");
+const chokidar_1 = require("chokidar");
+const route_generator_1 = require("../generator/route-generator");
+const route_validator_1 = require("../validator/route-validator");
+let watcherInstance = null;
+/**
+ * Starts watching the routes directory for changes
+ * Returns a cleanup function to stop watching
+ */
+function startRouteWatcher(options) {
+    const { routesDir, generatedDir, prefixes, verbose, onRegenerate, onError } = options;
+    // Close existing watcher if any
+    if (watcherInstance) {
+        watcherInstance.close();
+    }
+    const watcher = (0, chokidar_1.watch)((0, node_path_1.join)(routesDir, "**/*.{ts,tsx}"), {
+        ignoreInitial: true,
+        ignored: [
+            /(^|[/\\])\../, // Dotfiles
+            /node_modules/,
+            /\.test\./,
+            /\.spec\./,
+        ],
+    });
+    let debounceTimer = null;
+    const regenerate = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: debounced validate + generate
+        debounceTimer = setTimeout(() => {
+            try {
+                // Validate first
+                const errors = (0, route_validator_1.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
+                (0, route_generator_1.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: ${(0, node_path_1.relative)(routesDir, filePath)}`);
+        }
+        regenerate();
+    });
+    watcher.on("unlink", (filePath) => {
+        if (verbose) {
+            console.log(`[teardown/navigation] File removed: ${(0, node_path_1.relative)(routesDir, filePath)}`);
+        }
+        regenerate();
+    });
+    watcher.on("change", (filePath) => {
+        if (verbose) {
+            console.log(`[teardown/navigation] File changed: ${(0, node_path_1.relative)(routesDir, filePath)}`);
+        }
+        regenerate();
+    });
+    watcherInstance = watcher;
+    return () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        watcher.close();
+        watcherInstance = null;
+    };
+}
+/**
+ * Stops the route watcher if it's running
+ */
+function stopRouteWatcher() {
+    if (watcherInstance) {
+        watcherInstance.close();
+        watcherInstance = null;
+    }
+}
+/**
+ * Checks if the watcher is currently running
+ */
+function isWatcherRunning() {
+    return watcherInstance !== null;
+}

package/{src/watcher/index.ts → dist/watcher/index.d.ts}

@@ -1,5 +1,5 @@
 /**
  * Watcher module for @teardown/navigation-metro
  */
-
 export { isWatcherRunning, startRouteWatcher, stopRouteWatcher, type WatcherOptions } from "./file-watcher";
+//# sourceMappingURL=index.d.ts.map

package/dist/watcher/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/watcher/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/watcher/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Watcher module for @teardown/navigation-metro
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopRouteWatcher = exports.startRouteWatcher = exports.isWatcherRunning = void 0;
+var file_watcher_1 = require("./file-watcher");
+Object.defineProperty(exports, "isWatcherRunning", { enumerable: true, get: function () { return file_watcher_1.isWatcherRunning; } });
+Object.defineProperty(exports, "startRouteWatcher", { enumerable: true, get: function () { return file_watcher_1.startRouteWatcher; } });
+Object.defineProperty(exports, "stopRouteWatcher", { enumerable: true, get: function () { return file_watcher_1.stopRouteWatcher; } });

package/package.json

@@ -1,24 +1,27 @@
 {
 	"name": "@teardown/navigation-metro",
-	"version": "2.0.52",
+	"version": "2.0.56",
 	"description": "Metro plugin for @teardown/navigation type generation",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
 	},
-	"type": "module",
-	"main": "./src/index.ts",
+	"type": "commonjs",
+	"main": "./dist/index.js",
 	"exports": {
 		".": {
-			"types": "./src/index.ts",
-			"import": "./src/index.ts",
-			"default": "./src/index.ts"
-		}
+			"types": "./dist/index.d.ts",
+			"require": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json"
 	},
 	"files": [
-		"src/**/*"
+		"dist/**/*"
 	],
 	"scripts": {
+		"build": "tsc",
+		"prepublishOnly": "bun run build",
 		"typecheck": "bun x tsgo --noEmit",
 		"lint": "bun x biome lint --write ./src",
 		"fmt": "bun x biome format --write ./src",
@@ -39,7 +42,7 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.3.11",
-		"@teardown/tsconfig": "2.0.52",
+		"@teardown/tsconfig": "2.0.56",
 		"@types/node": "24.10.1",
 		"typescript": "5.9.3"
 	}