fix: add ability to select enviorenment and separate bun modules

Author: azat-io

docs/content/rules/sort-imports.mdx

@@ -276,6 +276,12 @@ You can use this to sort by the import name only, excluding the elements, when t
 
 **\*Note:** Only available for `line-length` type.
 
+### environment
+
+<sub>(default: `'node'`)</sub>
+
+This field is responsible for which modules will be counted as builtin modules. If you are using Bun, change the value to `'bun'`.
+
 ## Usage
 
 <CodeTabs

rules/sort-imports.ts

@@ -60,6 +60,7 @@ type Options<T extends string[]> = [
     type: 'alphabetical' | 'line-length' | 'natural'
     newlinesBetween: NewlinesBetweenValue
     groups: (Group<T>[] | Group<T>)[]
+    environment: 'node' | 'bun'
     internalPattern: string[]
     maxLineLength?: number
     order: 'desc' | 'asc'
@@ -136,6 +137,11 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
             minimum: 0,
             exclusiveMinimum: true,
           },
+          environment: {
+            enum: ['node', 'bun'],
+            default: 'node',
+            type: 'string',
+          },
         },
         allOf: [
           {
@@ -191,6 +197,7 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
       customGroups: { type: {}, value: {} },
       internalPattern: ['~/**'],
       type: 'alphabetical',
+      environment: 'node',
       ignoreCase: true,
       order: 'asc',
       groups: [],
@@ -270,7 +277,8 @@ export default createEslintRule<Options<string[]>, MESSAGE_ID>({
         return (
           builtinModules.includes(
             value.startsWith('node:') ? value.split('node:')[1] : value,
-          ) || bunModules.includes(value)
+          ) ||
+          (options.environment === 'bun' ? bunModules.includes(value) : false)
         )
       }
 

test/sort-imports.test.ts

@@ -1158,6 +1158,54 @@ describe(RULE_NAME, () => {
         ],
       },
     )
+
+    ruleTester.run(`${RULE_NAME}(${type}): allows to use bun modules`, rule, {
+      valid: [
+        {
+          code: dedent`
+            import { expect } from 'bun:test'
+            import { a } from 'a'
+          `,
+          options: [
+            {
+              ...options,
+              newlinesBetween: NewlinesBetweenValue.never,
+              groups: ['builtin', 'external', 'unknown'],
+              environment: 'bun',
+            },
+          ],
+        },
+      ],
+      invalid: [
+        {
+          code: dedent`
+            import { a } from 'a'
+            import { expect } from 'bun:test'
+          `,
+          output: dedent`
+            import { expect } from 'bun:test'
+            import { a } from 'a'
+          `,
+          options: [
+            {
+              ...options,
+              newlinesBetween: NewlinesBetweenValue.never,
+              groups: ['builtin', 'external', 'unknown'],
+              environment: 'bun',
+            },
+          ],
+          errors: [
+            {
+              messageId: 'unexpectedImportsOrder',
+              data: {
+                left: 'a',
+                right: 'bun:test',
+              },
+            },
+          ],
+        },
+      ],
+    })
   })
 
   describe(`${RULE_NAME}: sorting by natural order`, () => {
@@ -2301,6 +2349,54 @@ describe(RULE_NAME, () => {
         ],
       },
     )
+
+    ruleTester.run(`${RULE_NAME}(${type}): allows to use bun modules`, rule, {
+      valid: [
+        {
+          code: dedent`
+            import { expect } from 'bun:test'
+            import { a } from 'a'
+          `,
+          options: [
+            {
+              ...options,
+              newlinesBetween: NewlinesBetweenValue.never,
+              groups: ['builtin', 'external', 'unknown'],
+              environment: 'bun',
+            },
+          ],
+        },
+      ],
+      invalid: [
+        {
+          code: dedent`
+            import { a } from 'a'
+            import { expect } from 'bun:test'
+          `,
+          output: dedent`
+            import { expect } from 'bun:test'
+            import { a } from 'a'
+          `,
+          options: [
+            {
+              ...options,
+              newlinesBetween: NewlinesBetweenValue.never,
+              groups: ['builtin', 'external', 'unknown'],
+              environment: 'bun',
+            },
+          ],
+          errors: [
+            {
+              messageId: 'unexpectedImportsOrder',
+              data: {
+                left: 'a',
+                right: 'bun:test',
+              },
+            },
+          ],
+        },
+      ],
+    })
   })
 
   describe(`${RULE_NAME}: sorting by line length`, () => {
@@ -3569,6 +3665,54 @@ describe(RULE_NAME, () => {
         ).toBe('data[0].maxLineLength should be > 0')
       })
     })
+
+    ruleTester.run(`${RULE_NAME}(${type}): allows to use bun modules`, rule, {
+      valid: [
+        {
+          code: dedent`
+            import { expect } from 'bun:test'
+            import { a } from 'a'
+          `,
+          options: [
+            {
+              ...options,
+              newlinesBetween: NewlinesBetweenValue.never,
+              groups: ['builtin', 'external', 'unknown'],
+              environment: 'bun',
+            },
+          ],
+        },
+      ],
+      invalid: [
+        {
+          code: dedent`
+            import { a } from 'a'
+            import { expect } from 'bun:test'
+          `,
+          output: dedent`
+            import { expect } from 'bun:test'
+            import { a } from 'a'
+          `,
+          options: [
+            {
+              ...options,
+              newlinesBetween: NewlinesBetweenValue.never,
+              groups: ['builtin', 'external', 'unknown'],
+              environment: 'bun',
+            },
+          ],
+          errors: [
+            {
+              messageId: 'unexpectedImportsOrder',
+              data: {
+                left: 'a',
+                right: 'bun:test',
+              },
+            },
+          ],
+        },
+      ],
+    })
   })
 
   describe(`${RULE_NAME}: misc`, () => {
@@ -3643,7 +3787,6 @@ describe(RULE_NAME, () => {
         valid: [
           {
             code: dedent`
-              import { expect, test } from 'bun:test'
               import { writeFile } from 'node:fs/promises'
 
               import { useEffect } from 'react'
@@ -3660,10 +3803,8 @@ describe(RULE_NAME, () => {
             code: dedent`
               import { writeFile } from 'node:fs/promises'
               import { useEffect } from 'react'
-              import { expect, test } from 'bun:test'
             `,
             output: dedent`
-              import { expect, test } from 'bun:test'
               import { writeFile } from 'node:fs/promises'
 
               import { useEffect } from 'react'
@@ -3681,13 +3822,6 @@ describe(RULE_NAME, () => {
                   right: 'react',
                 },
               },
-              {
-                messageId: 'unexpectedImportsOrder',
-                data: {
-                  left: 'react',
-                  right: 'bun:test',
-                },
-              },
             ],
           },
         ],