feat(formatter/sort-imports): Support options.groups

Author: leaysgur

crates/oxc_formatter/src/ir_transform/sort_imports/import_unit.rs

@@ -13,6 +13,7 @@ pub struct SortableImport<'a> {
     pub import_line: SourceLine,
     pub group_idx: usize,
     pub normalized_source: Cow<'a, str>,
+    pub is_side_effect: bool,
     pub is_ignored: bool,
 }
 
@@ -24,6 +25,7 @@ impl<'a> SortableImport<'a> {
             // These will be computed by `collect_sort_keys()`
             group_idx: 0,
             normalized_source: Cow::Borrowed(""),
+            is_side_effect: false,
             is_ignored: false,
         }
     }
@@ -68,15 +70,43 @@ impl<'a> SortableImport<'a> {
         };
         self.group_idx = matcher.match_group(&options.groups);
 
-        // TODO: Check ignore comments?
-        self.is_ignored = !options.sort_side_effects && *is_side_effect;
+        // Store side-effect flag for use in sorting
+        self.is_side_effect = *is_side_effect;
+
+        // Determine if this import should be ignored (not moved between groups)
+        // Based on perfectionist's logic:
+        // - If sortSideEffects is true, never ignore
+        // - If sortSideEffects is false and this is a side-effect:
+        //   - Check if groups contain 'side-effect' or 'side-effect-style'
+        //   - If yes, allow regrouping (not ignored)
+        //   - If no, keep in original position (ignored)
+        let is_style_import = matcher.is_style_import;
+        let should_regroup_side_effect = has_side_effect_group(&options.groups);
+        let should_regroup_side_effect_style = has_side_effect_style_group(&options.groups);
+
+        self.is_ignored = !options.sort_side_effects
+            && *is_side_effect
+            && !should_regroup_side_effect
+            && (!is_style_import || !should_regroup_side_effect_style);
 
         self
     }
 }
 
 // ---
 
+/// Check if groups contain 'side-effect' group.
+fn has_side_effect_group(groups: &[Vec<String>]) -> bool {
+    groups.iter().any(|group| group.iter().any(|name| name == "side-effect"))
+}
+
+/// Check if groups contain 'side-effect-style' group.
+fn has_side_effect_style_group(groups: &[Vec<String>]) -> bool {
+    groups.iter().any(|group| group.iter().any(|name| name == "side-effect-style"))
+}
+
+// ---
+
 /// Helper for matching imports to configured groups.
 ///
 /// Contains all characteristics of an import needed to determine which group it belongs to,
@@ -126,81 +156,90 @@ impl ImportGroupMatcher {
     /// Generate all possible group names for this import, ordered by specificity.
     /// Returns group names in the format used by perfectionist.
     ///
-    /// Perfectionist format examples:
-    /// - `type-external` - type modifier + path selector
-    /// - `value-internal` - value modifier + path selector
-    /// - `type-import` - type modifier + import selector
-    /// - `external` - path selector only
+    /// This matches perfectionist's `generatePredefinedGroups` logic:
+    /// For each selector (in order), generate all modifier combinations with that selector.
+    ///
+    /// Example with selectors=`['style', 'parent']` and modifiers=`['value', 'default']`:
+    /// - value-default-style, value-style, default-style, style
+    /// - value-default-parent, value-parent, default-parent, parent
     fn generate_group_names(&self) -> Vec<String> {
         let selectors = self.selectors();
         let modifiers = self.modifiers();
 
         let mut group_names = Vec::new();
 
-        // Most specific: type/value modifier combined with path selectors
-        // e.g., "type-external", "value-internal", "type-parent"
-        let type_or_value_modifier = if self.is_type_import { "type" } else { "value" };
-
+        // For each selector, generate all modifier combinations
         for selector in &selectors {
-            // Skip the generic "type" selector since it's already in the modifier
-            if matches!(selector, ImportSelector::Type) {
+            // Skip "import" selector for now - it's handled specially at the end
+            if matches!(selector, ImportSelector::Import) {
                 continue;
             }
 
-            // For path-based selectors, combine with type/value modifier
-            if matches!(
+            // Path-type selectors are standalone (e.g., "parent-type", "external-type")
+            let is_path_type_selector = matches!(
                 selector,
-                ImportSelector::Builtin
-                    | ImportSelector::External
-                    | ImportSelector::Internal
-                    | ImportSelector::Parent
-                    | ImportSelector::Sibling
-                    | ImportSelector::Index
-            ) {
-                let name = format!("{}-{}", type_or_value_modifier, selector.as_str());
-                group_names.push(name);
-            }
-        }
-
-        // Add other modifier combinations for special selectors
-        for selector in &selectors {
-            // Skip path-based selectors (already handled above) and "import" selector
-            if matches!(
+                ImportSelector::BuiltinType
+                    | ImportSelector::ExternalType
+                    | ImportSelector::InternalType
+                    | ImportSelector::ParentType
+                    | ImportSelector::SiblingType
+                    | ImportSelector::IndexType
+            );
+
+            // For path-based selectors, use type/value as the primary modifier
+            let is_path_selector = matches!(
                 selector,
                 ImportSelector::Builtin
                     | ImportSelector::External
                     | ImportSelector::Internal
                     | ImportSelector::Parent
                     | ImportSelector::Sibling
                     | ImportSelector::Index
-                    | ImportSelector::Import
-                    | ImportSelector::Type
-            ) {
-                continue;
-            }
-
-            // For special selectors like side-effect, side-effect-style, style
-            // combine with relevant modifiers
-            for modifier in &modifiers {
-                let name = format!("{}-{}", modifier.as_str(), selector.as_str());
+            );
+
+            if is_path_type_selector {
+                // Path-type selectors are already in the format we want (e.g., "parent-type")
+                group_names.push(selector.as_str().to_string());
+            } else if matches!(selector, ImportSelector::Type) {
+                // Type selector: just add "type"
+                group_names.push("type".to_string());
+            } else if is_path_selector {
+                // For path selectors, combine with type/value modifier
+                let type_or_value = if self.is_type_import { "type" } else { "value" };
+                let name = format!("{}-{}", type_or_value, selector.as_str());
                 group_names.push(name);
+                // Also add bare selector name
+                group_names.push(selector.as_str().to_string());
+            } else {
+                // For special selectors (side-effect, style, etc.), combine with all modifiers
+                for modifier in &modifiers {
+                    let name = format!("{}-{}", modifier.as_str(), selector.as_str());
+                    group_names.push(name);
+                }
+                // Then add bare selector name
+                group_names.push(selector.as_str().to_string());
             }
-
-            // Selector-only name
-            group_names.push(selector.as_str().to_string());
         }
 
-        // Add "type-import" or "value-import" or just "import"
-        if self.is_type_import {
-            group_names.push("type-import".to_string());
+        // Add final "import" catch-all with modifiers
+        // This generates combinations like "side-effect-import", "type-import", "value-import", etc.
+        for modifier in &modifiers {
+            let name = format!("{}-import", modifier.as_str());
+            group_names.push(name);
         }
-
         group_names.push("import".to_string());
 
         group_names
     }
 
     /// Compute all selectors for this import, ordered from most to least specific.
+    ///
+    /// Order matches perfectionist implementation:
+    /// 1. Special selectors (side-effect-style, side-effect, style) - most specific
+    /// 2. Path-type selectors (parent-type, external-type, etc.) for type imports
+    /// 3. Type selector
+    /// 4. Path-based selectors (builtin, external, internal, parent, sibling, index)
+    /// 5. Catch-all import selector
     fn selectors(&self) -> Vec<ImportSelector> {
         let mut selectors = Vec::new();
 
@@ -214,10 +253,26 @@ impl ImportGroupMatcher {
         if self.is_style_import {
             selectors.push(ImportSelector::Style);
         }
+
+        // For type imports, add path-type selectors (e.g., "parent-type", "external-type")
+        // These come before the generic "type" selector
+        if self.is_type_import {
+            match self.path_kind {
+                ImportPathKind::Index => selectors.push(ImportSelector::IndexType),
+                ImportPathKind::Sibling => selectors.push(ImportSelector::SiblingType),
+                ImportPathKind::Parent => selectors.push(ImportSelector::ParentType),
+                ImportPathKind::Internal => selectors.push(ImportSelector::InternalType),
+                ImportPathKind::Builtin => selectors.push(ImportSelector::BuiltinType),
+                ImportPathKind::External => selectors.push(ImportSelector::ExternalType),
+                ImportPathKind::Unknown => {}
+            }
+        }
+
         // Type selector
         if self.is_type_import {
             selectors.push(ImportSelector::Type);
         }
+
         // Path-based selectors
         match self.path_kind {
             ImportPathKind::Index => selectors.push(ImportSelector::Index),
@@ -272,6 +327,18 @@ enum ImportSelector {
     SideEffect,
     /// Style file imports (CSS, SCSS, etc.)
     Style,
+    /// Type import from index file
+    IndexType,
+    /// Type import from sibling module
+    SiblingType,
+    /// Type import from parent module
+    ParentType,
+    /// Type import from internal module
+    InternalType,
+    /// Type import from built-in module
+    BuiltinType,
+    /// Type import from external module
+    ExternalType,
     /// Index file imports (`./`, `../`)
     Index,
     /// Sibling module imports (`./foo`)
@@ -296,6 +363,12 @@ impl ImportSelector {
             Self::SideEffectStyle => "side-effect-style",
             Self::SideEffect => "side-effect",
             Self::Style => "style",
+            Self::IndexType => "index-type",
+            Self::SiblingType => "sibling-type",
+            Self::ParentType => "parent-type",
+            Self::InternalType => "internal-type",
+            Self::BuiltinType => "builtin-type",
+            Self::ExternalType => "external-type",
             Self::Index => "index",
             Self::Sibling => "sibling",
             Self::Parent => "parent",
@@ -416,7 +489,8 @@ fn to_path_kind(source: &str) -> ImportPathKind {
     }
 
     if source.starts_with('.') {
-        if source == "." || source == ".." || source.ends_with('/') {
+        // Check for index file imports
+        if is_index_import(source) {
             return ImportPathKind::Index;
         }
         if source.starts_with("../") {
@@ -432,3 +506,17 @@ fn to_path_kind(source: &str) -> ImportPathKind {
 
     ImportPathKind::External
 }
+
+/// Check if an import is an index file import.
+fn is_index_import(source: &str) -> bool {
+    matches!(
+        source,
+        "." | "./"
+            | ".."
+            | "./index"
+            | "./index.js"
+            | "./index.ts"
+            | "./index.d.ts"
+            | "./index.d.js"
+    ) || source.ends_with('/')
+}