@teardown/metro-config 2.0.52 → 2.0.56

package/dist/index.js

@@ -128,11 +128,11 @@ function withTeardown(config, options = {}) {
     return finalConfig;
 }
 // Re-export Bun utilities
-const bun_2 = require("./bun");
+var bun_2 = require("./bun");
 Object.defineProperty(exports, "BUN_BLOCK_PATTERN", { enumerable: true, get: function () { return bun_2.BUN_BLOCK_PATTERN; } });
 Object.defineProperty(exports, "getBlockList", { enumerable: true, get: function () { return bun_2.getBlockList; } });
 // Re-export workspace utilities for advanced use cases
-const workspace_2 = require("./workspace");
+var workspace_2 = require("./workspace");
 Object.defineProperty(exports, "getMetroServerRoot", { enumerable: true, get: function () { return workspace_2.getMetroServerRoot; } });
 Object.defineProperty(exports, "getModulesPaths", { enumerable: true, get: function () { return workspace_2.getModulesPaths; } });
 Object.defineProperty(exports, "getRelativeProjectRoot", { enumerable: true, get: function () { return workspace_2.getRelativeProjectRoot; } });

package/package.json

@@ -1,26 +1,31 @@
 {
 	"name": "@teardown/metro-config",
-	"version": "2.0.52",
+	"version": "2.0.56",
 	"description": "Metro configuration for Teardown - Rust-powered transforms via Facetpack",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
 	},
+	"type": "commonjs",
 	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
 			"require": "./dist/index.js",
-			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
 		"./package.json": "./package.json"
 	},
+	"files": [
+		"dist/**/*"
+	],
 	"scripts": {
-		"typecheck": "bun x tsgo --noEmit --project ./tsconfig.json",
-		"build": "bun x tsgo --project ./tsconfig.json",
-		"dev": "bun x tsgo --watch --project ./tsconfig.json"
+		"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",
+		"check": "bun x biome check ./src"
 	},
 	"peerDependencies": {
 		"@ecrindigital/facetpack": "^0.2.0",
@@ -40,7 +45,7 @@
 		"resolve-workspace-root": "^2.0.0"
 	},
 	"devDependencies": {
-		"@teardown/tsconfig": "2.0.52",
+		"@teardown/tsconfig": "2.0.56",
 		"@types/bun": "1.3.5",
 		"typescript": "5.9.3"
 	},

package/src/bun.ts

@@ -1,95 +0,0 @@
-/**
- * Bun-specific Metro configuration utilities.
- *
- * Handles blocking of .bun directories which can cause Metro resolution issues.
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import type { ResolveRequestFn } from "./types";
-import { getModulesPaths } from "./workspace";
-
-/**
- * Block pattern for .bun directories.
- * Metro's blockList prevents processing of matched paths.
- */
-export const BUN_BLOCK_PATTERN = /.*[/\\]\.bun[/\\].*/;
-
-/**
- * Create a custom resolver that filters out .bun paths during module resolution.
- *
- * Metro's blockList only prevents processing after resolution, not during.
- * This resolver intercepts resolution and redirects away from .bun paths.
- */
-export function createBunAwareResolver(projectRoot: string, defaultResolveRequest: ResolveRequestFn): ResolveRequestFn {
-	const modulesPaths = getModulesPaths(projectRoot);
-
-	return (context: { resolveRequest: ResolveRequestFn }, moduleName: string, platform: string | null) => {
-		// Use Metro's default resolution
-		const result = defaultResolveRequest(context, moduleName, platform);
-
-		// If resolved path contains .bun, try to find alternative
-		if (result?.filePath?.includes("/.bun/")) {
-			for (const modulesPath of modulesPaths) {
-				if (modulesPath.includes("/.bun/")) continue;
-
-				const packagePath = path.join(modulesPath, moduleName);
-				if (existsSync(packagePath)) {
-					const mainFile = resolvePackageMain(packagePath);
-					if (mainFile) {
-						return { type: "sourceFile", filePath: mainFile };
-					}
-				}
-			}
-		}
-
-		return result;
-	};
-}
-
-/**
- * Resolve the main entry point of a package.
- */
-function resolvePackageMain(packagePath: string): string | null {
-	const packageJsonPath = path.join(packagePath, "package.json");
-	if (existsSync(packageJsonPath)) {
-		try {
-			const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-			const main = pkg.main || pkg.module || "index.js";
-			const mainPath = path.join(packagePath, main);
-
-			if (existsSync(mainPath)) {
-				return mainPath;
-			}
-			// Try with .js extension
-			const mainPathJs = mainPath + ".js";
-			if (existsSync(mainPathJs)) {
-				return mainPathJs;
-			}
-		} catch {
-			// Ignore parse errors
-		}
-	}
-
-	// Fallback to index.js
-	const indexPath = path.join(packagePath, "index.js");
-	if (existsSync(indexPath)) {
-		return indexPath;
-	}
-
-	return null;
-}
-
-/**
- * Get blockList patterns for Metro config.
- * Includes .bun directory blocking.
- */
-export function getBlockList(existingBlockList?: RegExp | RegExp[]): RegExp[] {
-	const blockListArray = Array.isArray(existingBlockList)
-		? existingBlockList
-		: existingBlockList
-			? [existingBlockList]
-			: [];
-
-	return [...blockListArray, BUN_BLOCK_PATTERN];
-}

package/src/index.ts

@@ -1,169 +0,0 @@
-/**
- * @teardown/metro-config
- *
- * Metro configuration wrapper that provides:
- * - Rust-powered transforms via Facetpack (36x faster than Babel)
- * - Automatic monorepo/workspace detection and configuration
- * - Bun-specific handling (blocks .bun directories)
- *
- * @example
- * ```js
- * // metro.config.js
- * const { withTeardown } = require('@teardown/metro-config')
- * const { getDefaultConfig } = require('@react-native/metro-config')
- *
- * module.exports = withTeardown(getDefaultConfig(__dirname))
- * ```
- *
- * @packageDocumentation
- */
-
-import { getStoredOptions, withFacetpack } from "@ecrindigital/facetpack";
-import { createBunAwareResolver, getBlockList } from "./bun";
-import type { MetroConfig, ResolveRequestFn, TeardownMetroOptions } from "./types";
-import {
-	getMetroServerRoot,
-	getModulesPaths,
-	getRelativeProjectRoot,
-	getWatchFolders,
-	getWorkspaceRoot,
-	isInMonorepo,
-} from "./workspace";
-
-/**
- * Wraps a Metro configuration with Teardown's enhancements.
- *
- * This function applies:
- * - Facetpack for Rust-powered transforms (36x faster)
- * - Automatic monorepo detection and watch folder configuration
- * - Bun-specific handling (.bun directory blocking)
- * - Proper nodeModulesPaths for monorepo resolution
- *
- * @param config - Base Metro configuration
- * @param options - Optional configuration options
- * @returns Enhanced Metro configuration
- *
- * @example
- * ```js
- * // Basic usage - all monorepo handling is automatic
- * const { withTeardown } = require('@teardown/metro-config')
- * const { getDefaultConfig } = require('@react-native/metro-config')
- *
- * module.exports = withTeardown(getDefaultConfig(__dirname))
- * ```
- *
- * @example
- * ```js
- * // With options
- * const { withTeardown } = require('@teardown/metro-config')
- * const { getDefaultConfig } = require('@react-native/metro-config')
- *
- * module.exports = withTeardown(getDefaultConfig(__dirname), {
- *   verbose: true,
- *   projectRoot: __dirname, // explicitly set project root
- * })
- * ```
- */
-export function withTeardown(config: MetroConfig, options: TeardownMetroOptions = {}): MetroConfig {
-	const { verbose, projectRoot: explicitProjectRoot, ...facetpackOptions } = options;
-
-	// Determine project root
-	const projectRoot = explicitProjectRoot || (config.projectRoot as string | undefined) || process.cwd();
-
-	if (verbose) {
-		console.log("[teardown/metro-config] Applying Teardown configuration...");
-		console.log(`[teardown/metro-config] Project root: ${projectRoot}`);
-	}
-
-	// Check if in monorepo
-	const inMonorepo = isInMonorepo(projectRoot);
-	if (verbose && inMonorepo) {
-		const workspaceRoot = getWorkspaceRoot(projectRoot);
-		console.log(`[teardown/metro-config] Monorepo detected: ${workspaceRoot}`);
-	}
-
-	// Get monorepo-aware watch folders
-	const additionalWatchFolders = getWatchFolders(projectRoot);
-	const existingWatchFolders = (config.watchFolders as string[] | undefined) || [];
-
-	// Get monorepo-aware node modules paths
-	const modulesPaths = getModulesPaths(projectRoot);
-	const existingNodeModulesPaths = (config.resolver?.nodeModulesPaths as string[] | undefined) || [];
-
-	// Get block list with .bun blocking
-	const blockList = getBlockList(config.resolver?.blockList as RegExp | RegExp[] | undefined);
-
-	// Create Bun-aware resolver
-	const defaultResolveRequest: ResolveRequestFn =
-		(config.resolver?.resolveRequest as ResolveRequestFn | undefined) ||
-		((context, moduleName, platform) => context.resolveRequest(context, moduleName, platform));
-
-	const bunAwareResolver = createBunAwareResolver(projectRoot, defaultResolveRequest);
-
-	// Build enhanced config
-	const enhancedConfig: MetroConfig = {
-		...config,
-		projectRoot,
-		watchFolders: [...new Set([...existingWatchFolders, ...additionalWatchFolders])],
-		resolver: {
-			...config.resolver,
-			blockList,
-			nodeModulesPaths: [...new Set([...modulesPaths, ...existingNodeModulesPaths])],
-			resolveRequest: bunAwareResolver,
-		},
-	};
-
-	// Set unstable_serverRoot for monorepo web support
-	if (inMonorepo) {
-		const serverRoot = getMetroServerRoot(projectRoot);
-		(enhancedConfig as Record<string, unknown>).unstable_serverRoot = serverRoot;
-
-		// Add relative project root to transformer cache key for cache collision prevention
-		const relativeRoot = getRelativeProjectRoot(projectRoot);
-		if (relativeRoot) {
-			const existingCacheKey =
-				(config.transformer as Record<string, unknown> | undefined)?.customTransformOptions || {};
-			enhancedConfig.transformer = {
-				...config.transformer,
-				customTransformOptions: {
-					...(existingCacheKey as Record<string, unknown>),
-					_teardownRelativeProjectRoot: relativeRoot,
-				},
-			};
-		}
-	}
-
-	if (verbose) {
-		const watchFoldersCount = (enhancedConfig.watchFolders as string[] | undefined)?.length || 0;
-		const nodeModulesPathsCount = (enhancedConfig.resolver?.nodeModulesPaths as string[] | undefined)?.length || 0;
-		console.log(`[teardown/metro-config] Watch folders: ${watchFoldersCount}`);
-		console.log(`[teardown/metro-config] Node modules paths: ${nodeModulesPathsCount}`);
-	}
-
-	// Apply Facetpack for Rust-powered transforms
-	const finalConfig = withFacetpack(enhancedConfig, facetpackOptions);
-
-	if (verbose) {
-		console.log("[teardown/metro-config] Metro config enhanced successfully");
-	}
-
-	return finalConfig;
-}
-
-// Re-export useful utilities from Facetpack
-export { getStoredOptions };
-
-// Re-export Bun utilities
-export { BUN_BLOCK_PATTERN, getBlockList } from "./bun";
-// Re-export workspace utilities for advanced use cases
-export {
-	getMetroServerRoot,
-	getModulesPaths,
-	getRelativeProjectRoot,
-	getWatchFolders,
-	getWorkspaceRoot,
-	isInMonorepo,
-} from "./workspace";
-
-// Re-export types
-export type { TeardownMetroOptions, MetroConfig };

package/src/types.ts

@@ -1,50 +0,0 @@
-/**
- * Type definitions for @teardown/metro-config
- */
-
-import type { MetroConfig as FacetpackMetroConfig } from "@ecrindigital/facetpack";
-
-/**
- * Extended Metro configuration type with proper resolver and transformer types
- */
-export interface MetroConfig extends FacetpackMetroConfig {
-	projectRoot?: string;
-	watchFolders?: string[];
-	resolver?: {
-		blockList?: RegExp | RegExp[];
-		nodeModulesPaths?: string[];
-		resolveRequest?: ResolveRequestFn;
-		[key: string]: unknown;
-	};
-	transformer?: {
-		customTransformOptions?: Record<string, unknown>;
-		[key: string]: unknown;
-	};
-	[key: string]: unknown;
-}
-
-/**
- * Metro resolve request function type
- */
-export type ResolveRequestFn = (
-	context: { resolveRequest: ResolveRequestFn },
-	moduleName: string,
-	platform: string | null
-) => { type: string; filePath: string } | null;
-
-/**
- * Teardown-specific Metro configuration options
- */
-export interface TeardownMetroOptions {
-	/**
-	 * Enable verbose logging for debugging
-	 * @default false
-	 */
-	verbose?: boolean;
-
-	/**
-	 * Explicit project root path.
-	 * If not provided, uses config.projectRoot or process.cwd().
-	 */
-	projectRoot?: string;
-}

package/src/workspace.ts

@@ -1,233 +0,0 @@
-/**
- * Workspace and monorepo detection utilities for Metro configuration.
- *
- * Uses `resolve-workspace-root` to detect workspace roots across:
- * - Yarn workspaces
- * - npm workspaces
- * - pnpm workspaces
- * - Bun workspaces
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { globSync } from "glob";
-
-/**
- * Read and parse a JSON file, returning null if invalid.
- */
-function readJsonFile(filePath: string): unknown {
-	const file = readFileSync(filePath, "utf8");
-	return JSON.parse(file);
-}
-
-/**
- * Check if a file is a valid JSON file.
- */
-function isValidJsonFile(filePath: string): boolean {
-	try {
-		readJsonFile(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Glob all package.json paths in a workspace.
- * Matches Expo's implementation pattern.
- *
- * @param workspaceRoot Root file path for the workspace
- * @param linkedPackages List of folders that contain linked node modules, ex: `['packages/*', 'apps/*']`
- * @returns List of valid package.json file paths
- */
-export function globAllPackageJsonPaths(workspaceRoot: string, linkedPackages: string[]): string[] {
-	return linkedPackages
-		.flatMap((pattern) => {
-			// Globs should only contain `/` as separator, even on Windows.
-			return globSync(path.posix.join(pattern, "package.json").replace(/\\/g, "/"), {
-				cwd: workspaceRoot,
-				absolute: true,
-				ignore: ["**/@(Carthage|Pods|node_modules)/**"],
-			}).filter((pkgPath) => isValidJsonFile(pkgPath));
-		})
-		.map((p) => path.join(p));
-}
-
-/**
- * Resolve all workspace package.json paths.
- *
- * @param workspaceRoot root file path for a workspace.
- * @returns list of package.json file paths that are linked to the workspace.
- */
-export function resolveAllWorkspacePackageJsonPaths(workspaceRoot: string): string[] {
-	try {
-		const workspaceGlobs = getWorkspaceGlobs(workspaceRoot);
-		if (!workspaceGlobs?.length) return [];
-		return globAllPackageJsonPaths(workspaceRoot, workspaceGlobs);
-	} catch {
-		return [];
-	}
-}
-
-/**
- * Resolve the workspace root directory.
- * Returns the project root if not in a workspace.
- */
-export function getWorkspaceRoot(projectRoot: string): string {
-	try {
-		// Dynamic import to handle the package
-		const { resolveWorkspaceRoot } = require("resolve-workspace-root") as {
-			resolveWorkspaceRoot: (cwd: string) => string | null;
-		};
-		const workspaceRoot = resolveWorkspaceRoot(projectRoot);
-		return workspaceRoot || projectRoot;
-	} catch {
-		// Fallback: check for turbo.jsonc or package.json with workspaces
-		return findMonorepoRootFallback(projectRoot);
-	}
-}
-
-/**
- * Fallback monorepo root detection for when resolve-workspace-root fails.
- * Checks for turbo.jsonc or package.json with workspaces field.
- */
-function findMonorepoRootFallback(startDir: string): string {
-	let current = startDir;
-	while (current !== path.dirname(current)) {
-		const turboConfig = path.join(current, "turbo.jsonc");
-		const turboJson = path.join(current, "turbo.json");
-		const packageJson = path.join(current, "package.json");
-
-		if (existsSync(turboConfig) || existsSync(turboJson)) {
-			return current;
-		}
-
-		if (existsSync(packageJson)) {
-			try {
-				const pkg = JSON.parse(readFileSync(packageJson, "utf8"));
-				if (pkg.workspaces) {
-					return current;
-				}
-			} catch {
-				// Ignore parse errors
-			}
-		}
-
-		current = path.dirname(current);
-	}
-	return startDir;
-}
-
-/**
- * Get workspace glob patterns from the workspace root.
- */
-export function getWorkspaceGlobs(workspaceRoot: string): string[] {
-	try {
-		const { getWorkspaceGlobs: getGlobs } = require("resolve-workspace-root") as {
-			getWorkspaceGlobs: (cwd: string) => string[] | null;
-		};
-		return getGlobs(workspaceRoot) ?? [];
-	} catch {
-		// Fallback: try to read from package.json
-		const packageJsonPath = path.join(workspaceRoot, "package.json");
-		if (existsSync(packageJsonPath)) {
-			try {
-				const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-				if (Array.isArray(pkg.workspaces)) {
-					return pkg.workspaces;
-				}
-				if (pkg.workspaces?.packages) {
-					return pkg.workspaces.packages;
-				}
-			} catch {
-				// Ignore parse errors
-			}
-		}
-		return [];
-	}
-}
-
-/**
- * Check if the project is in a monorepo (workspace root differs from project root).
- */
-export function isInMonorepo(projectRoot: string): boolean {
-	const workspaceRoot = getWorkspaceRoot(projectRoot);
-	return workspaceRoot !== projectRoot;
-}
-
-/**
- * Get the Metro server root for monorepo support.
- * This should be set as `unstable_serverRoot` in Metro config.
- */
-export function getMetroServerRoot(projectRoot: string): string {
-	// Can be disabled with environment variable
-	if (process.env.TEARDOWN_NO_METRO_WORKSPACE_ROOT) {
-		return projectRoot;
-	}
-	return getWorkspaceRoot(projectRoot);
-}
-
-/**
- * Helper to get unique items from an array.
- */
-function uniqueItems(items: string[]): string[] {
-	return [...new Set(items)];
-}
-
-/**
- * Get watch folders for Metro in a monorepo setup.
- *
- * Returns:
- * - Empty array if not in a monorepo
- * - Workspace root node_modules + all workspace package directories if in monorepo
- */
-export function getWatchFolders(projectRoot: string): string[] {
-	const resolvedProjectRoot = path.resolve(projectRoot);
-	const workspaceRoot = getMetroServerRoot(resolvedProjectRoot);
-
-	// Rely on default behavior in standard projects.
-	if (workspaceRoot === resolvedProjectRoot) {
-		return [];
-	}
-
-	const packages = resolveAllWorkspacePackageJsonPaths(workspaceRoot);
-	if (!packages?.length) {
-		return [];
-	}
-
-	return uniqueItems([path.join(workspaceRoot, "node_modules"), ...packages.map((pkg) => path.dirname(pkg))]);
-}
-
-/**
- * Get node module paths for Metro resolver in a monorepo setup.
- *
- * Returns paths in priority order:
- * 1. Project's local node_modules
- * 2. Workspace root node_modules (if in monorepo)
- */
-export function getModulesPaths(projectRoot: string): string[] {
-	const paths: string[] = [];
-
-	// Only add paths if in a monorepo - minimizes chance of Metro resolver breaking
-	const resolvedProjectRoot = path.resolve(projectRoot);
-	const workspaceRoot = getMetroServerRoot(resolvedProjectRoot);
-
-	if (workspaceRoot !== resolvedProjectRoot) {
-		paths.push(path.resolve(projectRoot, "node_modules"));
-		paths.push(path.resolve(workspaceRoot, "node_modules"));
-	}
-
-	return paths;
-}
-
-/**
- * Get the relative project root from workspace root.
- * Used for cache key generation to prevent collisions in monorepos.
- */
-export function getRelativeProjectRoot(projectRoot: string): string {
-	const workspaceRoot = getWorkspaceRoot(projectRoot);
-	if (workspaceRoot === projectRoot) {
-		return "";
-	}
-	return path.relative(workspaceRoot, projectRoot);
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-	"extends": "@teardown/tsconfig/tsconfig.bun.json",
-	"compilerOptions": {
-		"outDir": "./dist",
-		"rootDir": "./src",
-		"module": "CommonJS",
-		"moduleResolution": "node",
-		"esModuleInterop": true,
-		"declaration": true,
-		"declarationMap": true,
-		"emitDeclarationOnly": false,
-		"allowImportingTsExtensions": false,
-		"verbatimModuleSyntax": false
-	},
-	"include": ["src/**/*"],
-	"exclude": ["node_modules", "dist"]
-}