refactor(oxfmt): Rename FormatFileSource > FormatFileStrategy (#16635)

Addressed review in #16593

- Add `OxfmtOptions` struct
- Rename `FormatFileSource` to `FormatFileStrategy`
  - And include `package.json` as `ExternalFormatterPackageJson` variant

Author: leaysgur

apps/oxfmt/src/cli/service.rs

@@ -6,7 +6,7 @@ use rayon::prelude::*;
 use oxc_diagnostics::{DiagnosticSender, DiagnosticService};
 
 use super::command::OutputOptions;
-use crate::core::{FormatFileSource, FormatResult, SourceFormatter, utils};
+use crate::core::{FormatFileStrategy, FormatResult, SourceFormatter, utils};
 
 pub enum SuccessResult {
     Changed(String),
@@ -30,7 +30,7 @@ impl FormatService {
     /// Process entries as they are received from the channel
     pub fn run_streaming(
         &self,
-        rx_entry: mpsc::Receiver<FormatFileSource>,
+        rx_entry: mpsc::Receiver<FormatFileStrategy>,
         tx_error: &DiagnosticSender,
         tx_success: &mpsc::Sender<SuccessResult>,
     ) {

apps/oxfmt/src/cli/walk.rs

@@ -5,7 +5,7 @@ use std::{
 
 use ignore::gitignore::GitignoreBuilder;
 
-use crate::core::FormatFileSource;
+use crate::core::FormatFileStrategy;
 
 pub struct Walk {
     inner: ignore::WalkParallel,
@@ -166,8 +166,8 @@ impl Walk {
     }
 
     /// Stream entries through a channel as they are discovered
-    pub fn stream_entries(self) -> mpsc::Receiver<FormatFileSource> {
-        let (sender, receiver) = mpsc::channel::<FormatFileSource>();
+    pub fn stream_entries(self) -> mpsc::Receiver<FormatFileStrategy> {
+        let (sender, receiver) = mpsc::channel::<FormatFileStrategy>();
 
         // Spawn the walk operation in a separate thread
         rayon::spawn(move || {
@@ -202,7 +202,7 @@ fn load_ignore_paths(cwd: &Path, ignore_paths: &[PathBuf]) -> Vec<PathBuf> {
 // ---
 
 struct WalkBuilder {
-    sender: mpsc::Sender<FormatFileSource>,
+    sender: mpsc::Sender<FormatFileStrategy>,
 }
 
 impl<'s> ignore::ParallelVisitorBuilder<'s> for WalkBuilder {
@@ -212,7 +212,7 @@ impl<'s> ignore::ParallelVisitorBuilder<'s> for WalkBuilder {
 }
 
 struct WalkVisitor {
-    sender: mpsc::Sender<FormatFileSource>,
+    sender: mpsc::Sender<FormatFileStrategy>,
 }
 
 impl ignore::ParallelVisitor for WalkVisitor {
@@ -231,13 +231,13 @@ impl ignore::ParallelVisitor for WalkVisitor {
                     // Tier 2 = `.html`, `.json`, etc: Other files supported by Prettier
                     // (Tier 3 = `.astro`, `.svelte`, etc: Other files supported by Prettier plugins)
                     // Tier 4 = everything else: Not handled
-                    let Ok(format_file_source) = FormatFileSource::try_from(entry.into_path())
+                    let Ok(format_file_source) = FormatFileStrategy::try_from(entry.into_path())
                     else {
                         return ignore::WalkState::Continue;
                     };
 
                     #[cfg(not(feature = "napi"))]
-                    if matches!(format_file_source, FormatFileSource::ExternalFormatter { .. }) {
+                    if !matches!(format_file_source, FormatFileStrategy::OxcFormatter { .. }) {
                         return ignore::WalkState::Continue;
                     }
 

apps/oxfmt/src/core/format.rs

@@ -8,7 +8,7 @@ use oxc_formatter::{FormatOptions, Formatter, enable_jsx_source_type, get_parse_
 use oxc_parser::Parser;
 use oxc_span::SourceType;
 
-use super::FormatFileSource;
+use super::FormatFileStrategy;
 
 pub enum FormatResult {
     Success { is_changed: bool, code: String },
@@ -49,32 +49,22 @@ impl SourceFormatter {
     }
 
     /// Format a file based on its source type.
-    pub fn format(&self, entry: &FormatFileSource, source_text: &str) -> FormatResult {
+    pub fn format(&self, entry: &FormatFileStrategy, source_text: &str) -> FormatResult {
         let result = match entry {
-            FormatFileSource::OxcFormatter { path, source_type } => {
+            FormatFileStrategy::OxcFormatter { path, source_type } => {
                 self.format_by_oxc_formatter(source_text, path, *source_type)
             }
             #[cfg(feature = "napi")]
-            FormatFileSource::ExternalFormatter { path, parser_name } => {
-                let text_to_format: Cow<'_, str> =
-                    if self.is_sort_package_json && entry.is_package_json() {
-                        match sort_package_json::sort_package_json(source_text) {
-                            Ok(sorted) => Cow::Owned(sorted),
-                            Err(err) => {
-                                return FormatResult::Error(vec![OxcDiagnostic::error(format!(
-                                    "Failed to sort package.json: {}\n{err}",
-                                    path.display()
-                                ))]);
-                            }
-                        }
-                    } else {
-                        Cow::Borrowed(source_text)
-                    };
-
-                self.format_by_external_formatter(&text_to_format, path, parser_name)
+            FormatFileStrategy::ExternalFormatter { path, parser_name } => {
+                self.format_by_external_formatter(source_text, path, parser_name)
+            }
+            #[cfg(feature = "napi")]
+            FormatFileStrategy::ExternalFormatterPackageJson { path, parser_name } => {
+                self.format_by_external_formatter_package_json(source_text, path, parser_name)
             }
             #[cfg(not(feature = "napi"))]
-            FormatFileSource::ExternalFormatter { .. } => {
+            FormatFileStrategy::ExternalFormatter { .. }
+            | FormatFileStrategy::ExternalFormatterPackageJson { .. } => {
                 unreachable!("If `napi` feature is disabled, this should not be passed here")
             }
         };
@@ -170,4 +160,26 @@ impl SourceFormatter {
             ))
         })
     }
+
+    /// Format `package.json`: optionally sort then format by external formatter.
+    #[cfg(feature = "napi")]
+    fn format_by_external_formatter_package_json(
+        &self,
+        source_text: &str,
+        path: &Path,
+        parser_name: &str,
+    ) -> Result<String, OxcDiagnostic> {
+        let source_text: Cow<'_, str> = if self.is_sort_package_json {
+            Cow::Owned(sort_package_json::sort_package_json(source_text).map_err(|err| {
+                OxcDiagnostic::error(format!(
+                    "Failed to sort package.json: {}\n{err}",
+                    path.display()
+                ))
+            })?)
+        } else {
+            Cow::Borrowed(source_text)
+        };
+
+        self.format_by_external_formatter(&source_text, path, parser_name)
+    }
 }

apps/oxfmt/src/core/mod.rs

@@ -6,7 +6,7 @@ pub mod utils;
 mod external_formatter;
 
 pub use format::{FormatResult, SourceFormatter};
-pub use support::FormatFileSource;
+pub use support::FormatFileStrategy;
 
 #[cfg(feature = "napi")]
 pub use external_formatter::{