[autofix.ci] apply automated fixes

Author: autofix-ci[bot]

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

@@ -67,6 +67,7 @@ impl<'a> SortableImport<'a> {
             has_namespace_specifier: *has_namespace_specifier,
             has_named_specifier: *has_named_specifier,
             path_kind: to_path_kind(source),
+            source,
         };
         self.group_idx = matcher.match_group(&options.groups);
 
@@ -112,17 +113,18 @@ fn has_side_effect_style_group(groups: &[Vec<String>]) -> bool {
 /// Contains all characteristics of an import needed to determine which group it belongs to,
 /// such as whether it's a type import, side-effect import, style import, and what kind of path it uses.
 #[derive(Debug, Clone)]
-struct ImportGroupMatcher {
+struct ImportGroupMatcher<'a> {
     is_side_effect: bool,
     is_type_import: bool,
     is_style_import: bool,
     has_default_specifier: bool,
     has_namespace_specifier: bool,
     has_named_specifier: bool,
     path_kind: ImportPathKind,
+    source: &'a str,
 }
 
-impl ImportGroupMatcher {
+impl<'a> ImportGroupMatcher<'a> {
     /// Match this import against the configured groups and return the group index.
     /// Returns the index of the first matching group, or the index of "unknown" group if present,
     /// or the last index + 1 if no match found.
@@ -195,6 +197,7 @@ impl ImportGroupMatcher {
                     | ImportSelector::Parent
                     | ImportSelector::Sibling
                     | ImportSelector::Index
+                    | ImportSelector::Subpath
             );
 
             if is_path_type_selector {
@@ -274,15 +277,30 @@ impl ImportGroupMatcher {
         }
 
         // Path-based selectors
+        // Order matches perfectionist: index, sibling, parent, subpath, internal, builtin, external
         match self.path_kind {
             ImportPathKind::Index => selectors.push(ImportSelector::Index),
             ImportPathKind::Sibling => selectors.push(ImportSelector::Sibling),
             ImportPathKind::Parent => selectors.push(ImportSelector::Parent),
+            ImportPathKind::Internal => {}
+            ImportPathKind::Builtin => {}
+            ImportPathKind::External => {}
+            ImportPathKind::Unknown => {}
+        }
+
+        // Subpath selector (independent of path kind, comes after parent)
+        if is_subpath(self.source) {
+            selectors.push(ImportSelector::Subpath);
+        }
+
+        // Continue with remaining path-based selectors
+        match self.path_kind {
             ImportPathKind::Internal => selectors.push(ImportSelector::Internal),
             ImportPathKind::Builtin => selectors.push(ImportSelector::Builtin),
             ImportPathKind::External => selectors.push(ImportSelector::External),
-            ImportPathKind::Unknown => {}
+            _ => {}
         }
+
         // Catch-all selector
         selectors.push(ImportSelector::Import);
 
@@ -345,6 +363,8 @@ enum ImportSelector {
     Sibling,
     /// Parent module imports (`../foo`)
     Parent,
+    /// Subpath imports (package.json imports field, e.g., `#foo`)
+    Subpath,
     /// Internal module imports (matching internal patterns like `~/`, `@/`)
     Internal,
     /// Built-in module imports (`node:fs`, `fs`)
@@ -372,6 +392,7 @@ impl ImportSelector {
             Self::Index => "index",
             Self::Sibling => "sibling",
             Self::Parent => "parent",
+            Self::Subpath => "subpath",
             Self::Internal => "internal",
             Self::Builtin => "builtin",
             Self::External => "external",
@@ -520,3 +541,9 @@ fn is_index_import(source: &str) -> bool {
             | "./index.d.js"
     ) || source.ends_with('/')
 }
+
+/// Check if an import is a Node.js subpath import.
+/// Subpath imports start with '#' and are defined in package.json imports field.
+fn is_subpath(source: &str) -> bool {
+    source.starts_with('#')
+}

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

@@ -375,7 +375,9 @@ fn sort_within_group(
         let mut non_side_effect_iter = non_side_effect_indices.into_iter();
 
         for pos in 0..indices.len() {
-            if let Some(&(se_pos, se_idx)) = side_effect_iter.peek() && se_pos == pos {
+            if let Some(&(se_pos, se_idx)) = side_effect_iter.peek()
+                && se_pos == pos
+            {
                 result.push(se_idx);
                 side_effect_iter.next();
                 continue;

crates/oxc_formatter/tests/ir_transform/_sort-imports-tests.ref.snap

@@ -83,7 +83,6 @@ describe("misc", () => {
       options: [
         {
           groups: ["builtin", "external", "side-effect"],
-          newlinesBetween: "never",
         },
       ],
     });

crates/oxc_formatter/tests/ir_transform/sort_imports.rs

@@ -1574,4 +1574,43 @@ import { b } from "b";
 import { a } from "@/a";
 "#,
     );
+    // Supports subpath
+    assert_format(
+        r##"
+import a from "../a";
+import b from "./b";
+import subpath from "#subpath";
+import e from "timers";
+import c from "./index";
+import d from "d";
+
+import style from "style.css";
+"##,
+        r#"{
+  "experimentalSortImports": {
+    "groups": [
+        "style",
+        [
+          "index",
+          "internal",
+          "subpath",
+          "external",
+          "sibling",
+          "builtin",
+          "parent"
+        ]
+    ]
+  }
+}"#,
+        r##"
+import style from "style.css";
+
+import subpath from "#subpath";
+import a from "../a";
+import b from "./b";
+import c from "./index";
+import d from "d";
+import e from "timers";
+"##,
+    );
 }