Add --module-format parameter

Author: nojaf

rewatch/src/build.rs

@@ -579,6 +579,7 @@ pub fn compile_one(
     project_root: &Path,
     plain_output: bool,
     warn_error: Option<String>,
+    module_format: Option<String>,
 ) -> Result<String> {
     use std::fs;
 
@@ -593,6 +594,12 @@ pub fn compile_one(
         warn_error,
     )?;
 
+    // Determine which package spec to use for output
+    let root_config = build_state.get_root_config();
+    let package_specs = root_config.get_package_specs();
+
+    let selected_spec_index = select_package_spec(&package_specs, &module_format)?;
+
     // Step 2: Find target module from file path
     let target_module_name = find_module_for_file(&build_state, target_file)
         .ok_or_else(|| anyhow!("File not found in project: {}", target_file.display()))?;
@@ -633,13 +640,57 @@ pub fn compile_one(
     .map_err(|e| anyhow!("Compilation failed: {}", e))?;
 
     // Step 7: Find and read the generated JavaScript file
-    let js_path = get_js_output_path(&build_state, &target_module_name, target_file)?;
+    let js_path = get_js_output_path(&build_state, &target_module_name, selected_spec_index)?;
     let js_content = fs::read_to_string(&js_path)
         .map_err(|e| anyhow!("Failed to read generated JS file {}: {}", js_path.display(), e))?;
 
     Ok(js_content)
 }
 
+/// Select the appropriate package spec based on the module_format argument.
+///
+/// If module_format is specified, find the matching spec.
+/// If not specified and there are multiple specs, warn and use the first one.
+/// Returns the index of the selected package spec.
+fn select_package_spec(
+    package_specs: &[config::PackageSpec],
+    module_format: &Option<String>,
+) -> Result<usize> {
+    if package_specs.is_empty() {
+        return Err(anyhow!("No package-specs configured in rescript.json"));
+    }
+
+    match module_format {
+        Some(format) => {
+            // Find the package spec matching the requested format
+            package_specs
+                .iter()
+                .position(|spec| spec.module == *format)
+                .ok_or_else(|| {
+                    let available: Vec<&str> = package_specs.iter().map(|s| s.module.as_str()).collect();
+                    anyhow!(
+                        "Module format '{}' not found in package-specs. Available: {}",
+                        format,
+                        available.join(", ")
+                    )
+                })
+        }
+        None => {
+            // No format specified - use first, but warn if multiple exist
+            if package_specs.len() > 1 {
+                let available: Vec<&str> = package_specs.iter().map(|s| s.module.as_str()).collect();
+                eprintln!(
+                    "Warning: Multiple package-specs configured ({}). Using '{}'. \
+                     Specify --module-format to choose a different one.",
+                    available.join(", "),
+                    package_specs[0].module
+                );
+            }
+            Ok(0)
+        }
+    }
+}
+
 /// Find the module name for a given file path by searching through all modules.
 ///
 /// This performs a linear search through the build state's modules to match
@@ -705,11 +756,11 @@ fn get_dependency_closure(module_name: &str, build_state: &BuildState) -> AHashS
 /// Respects the package's configuration for output location and format:
 /// - in-source: JS file next to the .res file
 /// - out-of-source: JS file in lib/js or lib/es6
-/// - Uses first package spec to determine .js vs .mjs extension
+/// - Uses the selected package spec to determine .js vs .mjs extension
 fn get_js_output_path(
     build_state: &BuildCommandState,
     module_name: &str,
-    _original_file: &Path,
+    spec_index: usize,
 ) -> Result<PathBuf> {
     let module = build_state
         .get_module(module_name)
@@ -722,8 +773,8 @@ fn get_js_output_path(
     let root_config = build_state.get_root_config();
     let package_specs = root_config.get_package_specs();
     let package_spec = package_specs
-        .first()
-        .ok_or_else(|| anyhow!("No package specs configured"))?;
+        .get(spec_index)
+        .ok_or_else(|| anyhow!("Package spec index {} out of bounds", spec_index))?;
 
     let suffix = root_config.get_suffix(package_spec);
 

rewatch/src/cli.rs

@@ -466,6 +466,11 @@ pub enum Command {
         /// Path to a ReScript source file (.res or .resi)
         path: String,
 
+        /// Module format to use (commonjs or esmodule). If not specified and multiple
+        /// package-specs are configured, the first one is used with a warning.
+        #[arg(long)]
+        module_format: Option<String>,
+
         #[command(flatten)]
         warn_error: WarnErrorArg,
     },

rewatch/src/main.rs

@@ -50,7 +50,11 @@ fn main() -> Result<()> {
             println!("{}", build::get_compiler_args(Path::new(&path))?);
             std::process::exit(0);
         }
-        cli::Command::CompileFile { path, warn_error } => {
+        cli::Command::CompileFile {
+            path,
+            module_format,
+            warn_error,
+        } => {
             // Find project root by walking up from file path (same as CompilerArgs command)
             let file_path = Path::new(&path);
             let project_root = helpers::get_abs_path(
@@ -59,7 +63,13 @@ fn main() -> Result<()> {
 
             let _lock = get_lock(project_root.to_str().unwrap());
 
-            match build::compile_one(file_path, &project_root, plain_output, (*warn_error).clone()) {
+            match build::compile_one(
+                file_path,
+                &project_root,
+                plain_output,
+                (*warn_error).clone(),
+                module_format,
+            ) {
                 Ok(js_output) => {
                     // Output JS to stdout (clean for piping)
                     print!("{js_output}");