[New] order: add orderByFullPathString option

CHANGELOG.md

@@ -6,6 +6,9 @@ This change log adheres to standards from [Keep a CHANGELOG](https://keepachange
 
 ## [Unreleased]
 
+### Added
+- [`order`]: add `orderByFullPathString` option
+
 ## [2.32.0] - 2025-06-20
 
 ### Added

docs/rules/order.md

@@ -367,8 +367,8 @@ import index from './';
 
 ### `alphabetize`
 
-Valid values: `{ order?: "asc" | "desc" | "ignore", orderImportKind?: "asc" | "desc" | "ignore", caseInsensitive?: boolean }` \
-Default: `{ order: "ignore", orderImportKind: "ignore", caseInsensitive: false }`
+Valid values: `{ order?: "asc" | "desc" | "ignore", orderImportKind?: "asc" | "desc" | "ignore", caseInsensitive?: boolean, orderByFullPathString?: boolean }` \
+Default: `{ order: "ignore", orderImportKind: "ignore", caseInsensitive: false, orderByFullPathString: false }`
 
 Determine the sort order of imports within each [predefined group][18] or [`PathGroup`][8] alphabetically based on specifier.
 
@@ -385,6 +385,8 @@ Valid properties and their values include:
 
  - **`caseInsensitive`**: use `true` to ignore case and `false` to consider case when sorting
 
+ - **`orderByFullPathString`**: use `false` to split by paths and sort by each one and `true` to sort by the full un-split path string
+
 #### Example
 
 Given the following settings:

src/rules/order.js

@@ -433,7 +433,10 @@ function getSorter(alphabetizeOptions) {
     const importB = getNormalizedValue(nodeB, alphabetizeOptions.caseInsensitive);
     let result = 0;
 
-    if (!includes(importA, '/') && !includes(importB, '/')) {
+    if (
+      alphabetizeOptions.orderByFullPathString === true
+      || !includes(importA, '/') && !includes(importB, '/')
+    ) {
       result = compareString(importA, importB);
     } else {
       const A = importA.split('/');
@@ -831,8 +834,9 @@ function getAlphabetizeConfig(options) {
   const order = alphabetize.order || 'ignore';
   const orderImportKind = alphabetize.orderImportKind || 'ignore';
   const caseInsensitive = alphabetize.caseInsensitive || false;
+  const orderByFullPathString = alphabetize.orderByFullPathString || false;
 
-  return { order, orderImportKind, caseInsensitive };
+  return { order, orderImportKind, caseInsensitive, orderByFullPathString };
 }
 
 // TODO, semver-major: Change the default of "distinctGroup" from true to false
@@ -962,6 +966,10 @@ module.exports = {
                 enum: ['ignore', 'asc', 'desc'],
                 default: 'ignore',
               },
+              orderByFullPathString: {
+                type: 'boolean',
+                default: false,
+              },
             },
             additionalProperties: false,
           },

tests/src/rules/order.js

@@ -780,6 +780,48 @@ ruleTester.run('order', rule, {
         alphabetize: { order: 'desc' },
       }],
     }),
+    // Option alphabetize: {order: 'asc'} with orderByFullPathString: true`
+    test({
+      code: `
+        import a from "foo";
+        import b from "foo-bar";
+        import c from "foo/bar";
+        import d from "foo/barfoo";
+      `,
+      options: [{ alphabetize: { order: 'asc' }, orderByFullPathString: true }],
+    }),
+    // Option alphabetize: {order: 'asc'} with orderByFullPathString: true
+    test({
+      code: `
+        import a from "foo";
+        import b from "foo-bar";
+        import c from "foo/foobar/bar";
+        import d from "foo/foobar/barfoo";
+      `,
+      options: [{ alphabetize: { order: 'asc' }, orderByFullPathString: true }],
+    }),
+    // Option alphabetize: {order: 'desc'} with orderByFullPathString: true
+    test({
+      code: `
+        import d from "foo/barfoo";
+        import c from "foo/bar";
+        import b from "foo-bar";
+        import a from "foo";
+      `,
+      options: [{ alphabetize: { order: 'desc' }, orderByFullPathString: true }],
+    }),
+    // Option alphabetize: {order: 'desc'} with orderByFullPathString: true and file names having non-alphanumeric characters.
+    test({
+      code: `
+        import d from "foo/barfoo";
+        import b from "foo-bar";
+        import c from "foo,bar";
+        import a from "foo";`,
+      options: [{
+        alphabetize: { order: 'desc' },
+        orderByFullPathString: true,
+      }],
+    }),
     // Option alphabetize with newlines-between: {order: 'asc', newlines-between: 'always'}
     test({
       code: `
@@ -2646,6 +2688,28 @@ ruleTester.run('order', rule, {
         message: '`foo-bar` import should occur after import of `foo/barfoo`',
       }],
     }),
+    // Option alphabetize: {order: 'asc'} with orderByFullPathString: true
+    test({
+      code: `
+        import a from "foo";
+        import c from "foo/bar";
+        import d from "foo/barfoo";
+        import b from "foo-bar";
+      `,
+      options: [{
+        alphabetize: { order: 'asc' },
+        orderByFullPathString: true,
+      }],
+      output: `
+        import a from "foo";
+        import b from "foo-bar";
+        import c from "foo/bar";
+        import d from "foo/barfoo";
+      `,
+      errors: [{
+        message: '`foo/barfoo` import should occur after import of `foo-bar`',
+      }],
+    }),
     // Option alphabetize {order: 'asc': caseInsensitive: true}
     test({
       code: `