refactor(order): invert naming

Author: Ted Weatherly

CHANGELOG.md

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

docs/rules/order.md

@@ -367,8 +367,8 @@ import index from './';
 
 ### `alphabetize`
 
-Valid values: `{ order?: "asc" | "desc" | "ignore", orderImportKind?: "asc" | "desc" | "ignore", caseInsensitive?: boolean, orderBySplitPaths?: boolean }` \
-Default: `{ order: "ignore", orderImportKind: "ignore", caseInsensitive: false, orderBySplitPaths: true }`
+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,7 +385,7 @@ Valid properties and their values include:
 
  - **`caseInsensitive`**: use `true` to ignore case and `false` to consider case when sorting
 
- - **`orderBySplitPaths`**: use `true` to split by paths and sort by each one and `false` to sort by the full un-split path string
+ - **`orderByFullPathString`**: use `false` to split by paths and sort by each one and `true` to sort by the full un-split path string
 
 #### Example
 

src/rules/order.js

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

tests/src/rules/order.js

@@ -780,37 +780,37 @@ ruleTester.run('order', rule, {
         alphabetize: { order: 'desc' },
       }],
     }),
-    // Option alphabetize: {order: 'asc'} with orderBySplitPaths: false`
+    // 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' }, orderBySplitPaths: false }],
+      options: [{ alphabetize: { order: 'asc' }, orderByFullPathString: true }],
     }),
-    // Option alphabetize: {order: 'asc'} with orderBySplitPaths: false
+    // 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' }, orderBySplitPaths: false }],
+      options: [{ alphabetize: { order: 'asc' }, orderByFullPathString: true }],
     }),
-    // Option alphabetize: {order: 'desc'} with orderBySplitPaths: false
+    // 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' }, orderBySplitPaths: false }],
+      options: [{ alphabetize: { order: 'desc' }, orderByFullPathString: true }],
     }),
-    // Option alphabetize: {order: 'desc'} with orderBySplitPaths: false and file names having non-alphanumeric characters.
+    // Option alphabetize: {order: 'desc'} with orderByFullPathString: true and file names having non-alphanumeric characters.
     test({
       code: `
         import d from "foo/barfoo";
@@ -819,7 +819,7 @@ ruleTester.run('order', rule, {
         import a from "foo";`,
       options: [{
         alphabetize: { order: 'desc' },
-        orderBySplitPaths: false,
+        orderByFullPathString: true,
       }],
     }),
     // Option alphabetize with newlines-between: {order: 'asc', newlines-between: 'always'}
@@ -2688,7 +2688,7 @@ ruleTester.run('order', rule, {
         message: '`foo-bar` import should occur after import of `foo/barfoo`',
       }],
     }),
-    // Option alphabetize: {order: 'asc'} with orderBySplitPaths: false
+    // Option alphabetize: {order: 'asc'} with orderByFullPathString: true
     test({
       code: `
         import a from "foo";
@@ -2698,7 +2698,7 @@ ruleTester.run('order', rule, {
       `,
       options: [{
         alphabetize: { order: 'asc' },
-        orderBySplitPaths: false,
+        orderByFullPathString: true,
       }],
       output: `
         import a from "foo";