@borela-tech/eslint-config 1.3.3 → 2.0.0

package/bin/lint

@@ -3,10 +3,11 @@
 SCRIPT_DIR=$(dirname -- "${BASH_SOURCE[0]}")
 pushd "$SCRIPT_DIR/.." > /dev/null
 
+./bin/build
 npx eslint \
   --ext ts \
   --max-warnings 0 \
   --report-unused-disable-directives \
-  src
+  .
 
 popd > /dev/null

package/bin/test

@@ -0,0 +1,12 @@
+#!/usr/bin/env -S bash -e -o pipefail
+
+SCRIPT_DIR=$(dirname -- "${BASH_SOURCE[0]}")
+pushd "$SCRIPT_DIR/.." > /dev/null
+
+./bin/build
+node \
+  --import jiti/register \
+  --test \
+  src/rules/__tests__/*.test.ts
+
+popd > /dev/null

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+import * as eslint_config from 'eslint/config';
 
-declare const CONFIG: _typescript_eslint_utils_ts_eslint.FlatConfig.ConfigArray;
+declare const CONFIG: eslint_config.Config[];
 
 export { CONFIG };

package/dist/index.js

@@ -4,13 +4,316 @@ import react from "eslint-plugin-react";
 import reactHooks from "eslint-plugin-react-hooks";
 import stylistic from "@stylistic/eslint-plugin";
 import typescript from "typescript-eslint";
-var CONFIG = typescript.config(
+import { defineConfig } from "eslint/config";
+
+// src/rules/individualImports.ts
+var individualImports = {
+  meta: {
+    docs: {
+      description: "Enforce individual imports instead of grouped imports",
+      recommended: true
+    },
+    fixable: "code",
+    messages: {
+      individualImports: "Use individual imports instead of grouped imports."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (node.specifiers.length <= 1)
+          return;
+        context.report({
+          node,
+          messageId: "individualImports",
+          fix(fixer) {
+            const source = node.source.raw;
+            const specifiers = node.specifiers.map((importSpecifier) => {
+              if (importSpecifier.type === "ImportSpecifier")
+                return `import {${importSpecifier.local.name}} from ${source}`;
+              return null;
+            }).filter(Boolean);
+            if (specifiers.length !== node.specifiers.length)
+              return null;
+            return fixer.replaceText(
+              node,
+              specifiers.join("\n")
+            );
+          }
+        });
+      }
+    };
+  }
+};
+
+// src/rules/sortedImports/categorizeImport.ts
+function categorizeImport(declaration) {
+  if (declaration.specifiers.length === 0)
+    return "side-effect";
+  if (declaration.specifiers.some((s) => s.type === "ImportDefaultSpecifier"))
+    return "default";
+  return "named";
+}
+
+// src/rules/sortedImports/getSortKey.ts
+function getSortKey(declaration) {
+  const group = categorizeImport(declaration);
+  if (group === "side-effect")
+    return declaration.source.value.toLowerCase();
+  if (group === "default") {
+    const defaultSpecifier = declaration.specifiers.find(
+      (s) => s.type === "ImportDefaultSpecifier"
+    );
+    return defaultSpecifier?.local.name.toLowerCase() ?? "";
+  }
+  return "";
+}
+
+// src/rules/sortedImports/categorizeImports.ts
+function categorizeImports(declarations) {
+  return declarations.map((declaration) => ({
+    declaration,
+    group: categorizeImport(declaration),
+    sortKey: getSortKey(declaration)
+  }));
+}
+
+// src/rules/sortedImports/checkAlphabeticalSorting.ts
+function checkAlphabeticalSorting(categorized) {
+  const errors = [];
+  for (const group of ["side-effect", "default"]) {
+    const groupImports = categorized.filter((c) => c.group === group);
+    const sorted = [...groupImports].sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+    for (let i = 0; i < groupImports.length; i++) {
+      if (groupImports[i] !== sorted[i]) {
+        errors.push({
+          node: groupImports[i].declaration,
+          messageId: "sortedImports"
+        });
+      }
+    }
+  }
+  return errors;
+}
+
+// src/rules/sortedImports/checkGroupOrdering.ts
+function checkGroupOrdering(categorized) {
+  const groupOrder = ["side-effect", "default", "named"];
+  const errors = [];
+  let currentGroupIndex = -1;
+  for (const { declaration, group } of categorized) {
+    const groupIndex = groupOrder.indexOf(group);
+    if (groupIndex < currentGroupIndex) {
+      errors.push({
+        node: declaration,
+        messageId: "wrongGroup"
+      });
+    } else
+      currentGroupIndex = groupIndex;
+  }
+  return errors;
+}
+
+// src/rules/sortedImports/getSpecifierName.ts
+function getSpecifierName(specifier) {
+  return specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+}
+
+// src/rules/sortedImports/areSpecifiersSorted.ts
+function areSpecifiersSorted(specifiers) {
+  const names = specifiers.map((s) => getSpecifierName(s));
+  const sorted = [...names].sort(
+    (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
+  );
+  return names.every((name, i) => name === sorted[i]);
+}
+
+// src/rules/sortedImports/getNamedSpecifiers.ts
+function getNamedSpecifiers(declaration) {
+  return declaration.specifiers.filter(
+    (s) => s.type === "ImportSpecifier"
+  );
+}
+
+// src/rules/sortedImports/checkSpecifiersSorting.ts
+function checkSpecifiersSorting(categorized) {
+  const errors = [];
+  const namedImports = categorized.filter((c) => c.group === "named");
+  for (const { declaration } of namedImports) {
+    const specifiers = getNamedSpecifiers(declaration);
+    if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+      errors.push({
+        node: declaration,
+        messageId: "sortedNames"
+      });
+    }
+  }
+  return errors;
+}
+
+// src/rules/sortedImports/sortSpecifiersText.ts
+function sortSpecifiersText(specifiers, sourceCode) {
+  const sorted = [...specifiers].sort((a, b) => {
+    const lowerA = getSpecifierName(a).toLowerCase();
+    const lowerB = getSpecifierName(b).toLowerCase();
+    return lowerA.localeCompare(lowerB);
+  });
+  return sorted.map((s) => sourceCode.getText(s)).join(", ");
+}
+
+// src/rules/sortedImports/createFix/formatNamedImport.ts
+function formatNamedImport(declaration, sourceCode) {
+  const specifiers = getNamedSpecifiers(declaration);
+  if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+    const importText = sourceCode.getText(declaration);
+    const specifiersStart = importText.indexOf("{");
+    const specifiersEnd = importText.lastIndexOf("}");
+    const before = importText.substring(0, specifiersStart + 1);
+    const after = importText.substring(specifiersEnd);
+    const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode);
+    return before + " " + sortedSpecifiers + " " + after;
+  }
+  return sourceCode.getText(declaration);
+}
+
+// src/rules/sortedImports/createFix/buildSortedCode.ts
+function buildSortedCode(grouped, sourceCode) {
+  const groupOrder = ["side-effect", "default", "named"];
+  const sortedCode = [];
+  for (const group of groupOrder) {
+    for (const { declaration } of grouped[group]) {
+      if (group === "named")
+        sortedCode.push(formatNamedImport(declaration, sourceCode));
+      else
+        sortedCode.push(sourceCode.getText(declaration));
+    }
+  }
+  return sortedCode;
+}
+
+// src/rules/sortedImports/createFix/findLastImportIndex.ts
+function findLastImportIndex(programBody) {
+  let lastIndex = 0;
+  for (let i = 0; i < programBody.length; i++) {
+    if (programBody[i].type === "ImportDeclaration")
+      lastIndex = i;
+    else
+      break;
+  }
+  return lastIndex;
+}
+
+// src/rules/sortedImports/createFix/getReplacementRange.ts
+function getReplacementRange(programBody, sourceCode) {
+  const fullText = sourceCode.getText();
+  const lastIndex = findLastImportIndex(programBody);
+  const firstImport = programBody[0];
+  const lastImport = programBody[lastIndex];
+  const start = firstImport.range[0];
+  let end = lastImport.range[1];
+  for (let i = end; i < fullText.length; i++) {
+    const char = fullText[i];
+    if (char === "\n" || char === " " || char === "	")
+      end++;
+    else
+      break;
+  }
+  return { start, end };
+}
+
+// src/rules/sortedImports/createFix/groupImportsByType.ts
+function groupImportsByType(categorized) {
+  const grouped = {
+    "side-effect": [],
+    default: [],
+    named: []
+  };
+  for (const item of categorized)
+    grouped[item.group].push(item);
+  return grouped;
+}
+
+// src/rules/sortedImports/createFix/sortImportGroups.ts
+function sortImportGroups(grouped) {
+  grouped["side-effect"].sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+  grouped["default"].sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+}
+
+// src/rules/sortedImports/createFix/index.ts
+function createFix(fixer, importDeclarations, sourceCode, programBody) {
+  const range = getReplacementRange(programBody, sourceCode);
+  const categorized = categorizeImports(importDeclarations);
+  const grouped = groupImportsByType(categorized);
+  sortImportGroups(grouped);
+  const sortedCode = buildSortedCode(grouped, sourceCode).join("\n");
+  return fixer.replaceTextRange(
+    [range.start, range.end],
+    sortedCode
+  );
+}
+
+// src/rules/sortedImports/getImportDeclarations.ts
+function getImportDeclarations(programBody) {
+  return programBody.filter(
+    (statement) => statement.type === "ImportDeclaration"
+  );
+}
+
+// src/rules/sortedImports/index.ts
+var sortedImports = {
+  meta: {
+    docs: {
+      description: "Enforce sorted imports alphabetically",
+      recommended: true
+    },
+    fixable: "code",
+    messages: {
+      sortedImports: "Imports should be sorted alphabetically",
+      sortedNames: "Named imports should be sorted alphabetically",
+      wrongGroup: "Import is in wrong group"
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const declarations = getImportDeclarations(node.body);
+        if (declarations.length === 0)
+          return;
+        const categorized = categorizeImports(declarations);
+        const errors = [
+          ...checkGroupOrdering(categorized),
+          ...checkAlphabeticalSorting(categorized),
+          ...checkSpecifiersSorting(categorized)
+        ];
+        for (const error of errors) {
+          context.report({
+            node: error.node,
+            messageId: error.messageId,
+            fix(fixer) {
+              const sourceCode = context.sourceCode;
+              return createFix(fixer, declarations, sourceCode, node.body);
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/index.ts
+var CONFIG = defineConfig([
   {
     ignores: [
       "src/graphql/sdk.ts",
       "**/node_modules/**",
       "**/dist/**"
-    ],
+    ]
+  },
+  {
     settings: {
       react: {
         version: "19"
@@ -28,6 +331,20 @@ var CONFIG = typescript.config(
     },
     rules: reactHooks.configs.recommended.rules
   },
+  {
+    plugins: {
+      "@borela-tech": {
+        rules: {
+          "individual-imports": individualImports,
+          "sorted-imports": sortedImports
+        }
+      }
+    },
+    rules: {
+      "@borela-tech/individual-imports": "error",
+      "@borela-tech/sorted-imports": "error"
+    }
+  },
   {
     rules: {
       "capitalized-comments": [
@@ -102,24 +419,10 @@ var CONFIG = typescript.config(
         { beforeStatementContinuationChars: "always" }
       ],
       "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/consistent-indexed-object-style": "off",
-      "sort-imports": [
-        "error",
-        {
-          allowSeparatedGroups: true,
-          ignoreCase: true,
-          ignoreMemberSort: false,
-          memberSyntaxSortOrder: [
-            "none",
-            "all",
-            "single",
-            "multiple"
-          ]
-        }
-      ]
+      "@typescript-eslint/consistent-indexed-object-style": "off"
     }
   }
-);
+]);
 export {
   CONFIG
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import eslint from '@eslint/js'\nimport react from 'eslint-plugin-react'\nimport reactHooks from 'eslint-plugin-react-hooks'\nimport stylistic from '@stylistic/eslint-plugin'\nimport typescript from 'typescript-eslint'\n\nexport const CONFIG = typescript.config(\n  {\n    ignores: [\n      'src/graphql/sdk.ts',\n      '**/node_modules/**',\n      '**/dist/**',\n    ],\n    settings: {\n      react: {\n        version: '19',\n      },\n    },\n  },\n  eslint.configs.recommended,\n  react.configs.flat.recommended,\n  stylistic.configs.recommended,\n  typescript.configs.recommended,\n  typescript.configs.stylistic,\n  {\n    plugins: {\n      'react-hooks': reactHooks,\n    },\n    rules: reactHooks.configs.recommended.rules,\n  },\n  {\n    rules: {\n      'capitalized-comments': [\n        'error',\n        'always',\n        {ignoreConsecutiveComments: true},\n      ],\n      'react/react-in-jsx-scope': 'off',\n      '@stylistic/arrow-parens': [\n        'error',\n        'as-needed',\n      ],\n      '@stylistic/array-bracket-newline': [\n        'error',\n        'consistent',\n      ],\n      '@stylistic/array-bracket-spacing': [\n        'error',\n        'never',\n      ],\n      '@stylistic/array-element-newline': [\n        'error',\n        'consistent',\n      ],\n      '@stylistic/block-spacing': 'off',\n      '@stylistic/brace-style': [\n        'error',\n        '1tbs',\n        {allowSingleLine: true},\n      ],\n      '@stylistic/indent': [\n        'error',\n        2,\n        {ignoredNodes: ['TSMappedType > *']},\n      ],\n      '@stylistic/jsx-tag-spacing': [\n        'error',\n        {\n          afterOpening: 'never',\n          beforeClosing: 'never',\n          beforeSelfClosing: 'never',\n          closingSlash: 'never',\n        },\n      ],\n      '@stylistic/jsx-wrap-multilines': 'off',\n      '@stylistic/lines-between-class-members': 'off',\n      '@stylistic/object-curly-newline': [\n        'error',\n        {consistent: true},\n      ],\n      '@stylistic/object-curly-spacing': [\n        'error',\n        'never',\n      ],\n      '@stylistic/operator-linebreak': [\n        'error',\n        'before',\n        {overrides: {'=': 'after'}},\n      ],\n      '@stylistic/quotes': [\n        'error',\n        'single',\n        {avoidEscape: true},\n      ],\n      '@stylistic/quote-props': [\n        'error',\n        'as-needed',\n      ],\n      '@stylistic/semi': [\n        'error',\n        'never',\n        {beforeStatementContinuationChars: 'always'},\n      ],\n      '@typescript-eslint/no-empty-function': 'off',\n      '@typescript-eslint/consistent-indexed-object-style': 'off',\n      'sort-imports': [\n        'error',\n        {\n          allowSeparatedGroups: true,\n          ignoreCase: true,\n          ignoreMemberSort: false,\n          memberSyntaxSortOrder: [\n            'none',\n            'all',\n            'single',\n            'multiple',\n          ],\n        },\n      ],\n    },\n  },\n)\n"],"mappings":";AAAA,OAAO,YAAY;AACnB,OAAO,WAAW;AAClB,OAAO,gBAAgB;AACvB,OAAO,eAAe;AACtB,OAAO,gBAAgB;AAEhB,IAAM,SAAS,WAAW;AAAA,EAC/B;AAAA,IACE,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,UAAU;AAAA,MACR,OAAO;AAAA,QACL,SAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF;AAAA,EACA,OAAO,QAAQ;AAAA,EACf,MAAM,QAAQ,KAAK;AAAA,EACnB,UAAU,QAAQ;AAAA,EAClB,WAAW,QAAQ;AAAA,EACnB,WAAW,QAAQ;AAAA,EACnB;AAAA,IACE,SAAS;AAAA,MACP,eAAe;AAAA,IACjB;AAAA,IACA,OAAO,WAAW,QAAQ,YAAY;AAAA,EACxC;AAAA,EACA;AAAA,IACE,OAAO;AAAA,MACL,wBAAwB;AAAA,QACtB;AAAA,QACA;AAAA,QACA,EAAC,2BAA2B,KAAI;AAAA,MAClC;AAAA,MACA,4BAA4B;AAAA,MAC5B,2BAA2B;AAAA,QACzB;AAAA,QACA;AAAA,MACF;AAAA,MACA,oCAAoC;AAAA,QAClC;AAAA,QACA;AAAA,MACF;AAAA,MACA,oCAAoC;AAAA,QAClC;AAAA,QACA;AAAA,MACF;AAAA,MACA,oCAAoC;AAAA,QAClC;AAAA,QACA;AAAA,MACF;AAAA,MACA,4BAA4B;AAAA,MAC5B,0BAA0B;AAAA,QACxB;AAAA,QACA;AAAA,QACA,EAAC,iBAAiB,KAAI;AAAA,MACxB;AAAA,MACA,qBAAqB;AAAA,QACnB;AAAA,QACA;AAAA,QACA,EAAC,cAAc,CAAC,kBAAkB,EAAC;AAAA,MACrC;AAAA,MACA,8BAA8B;AAAA,QAC5B;AAAA,QACA;AAAA,UACE,cAAc;AAAA,UACd,eAAe;AAAA,UACf,mBAAmB;AAAA,UACnB,cAAc;AAAA,QAChB;AAAA,MACF;AAAA,MACA,kCAAkC;AAAA,MAClC,0CAA0C;AAAA,MAC1C,mCAAmC;AAAA,QACjC;AAAA,QACA,EAAC,YAAY,KAAI;AAAA,MACnB;AAAA,MACA,mCAAmC;AAAA,QACjC;AAAA,QACA;AAAA,MACF;AAAA,MACA,iCAAiC;AAAA,QAC/B;AAAA,QACA;AAAA,QACA,EAAC,WAAW,EAAC,KAAK,QAAO,EAAC;AAAA,MAC5B;AAAA,MACA,qBAAqB;AAAA,QACnB;AAAA,QACA;AAAA,QACA,EAAC,aAAa,KAAI;AAAA,MACpB;AAAA,MACA,0BAA0B;AAAA,QACxB;AAAA,QACA;AAAA,MACF;AAAA,MACA,mBAAmB;AAAA,QACjB;AAAA,QACA;AAAA,QACA,EAAC,kCAAkC,SAAQ;AAAA,MAC7C;AAAA,MACA,wCAAwC;AAAA,MACxC,sDAAsD;AAAA,MACtD,gBAAgB;AAAA,QACd;AAAA,QACA;AAAA,UACE,sBAAsB;AAAA,UACtB,YAAY;AAAA,UACZ,kBAAkB;AAAA,UAClB,uBAAuB;AAAA,YACrB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/rules/individualImports.ts","../src/rules/sortedImports/categorizeImport.ts","../src/rules/sortedImports/getSortKey.ts","../src/rules/sortedImports/categorizeImports.ts","../src/rules/sortedImports/checkAlphabeticalSorting.ts","../src/rules/sortedImports/checkGroupOrdering.ts","../src/rules/sortedImports/getSpecifierName.ts","../src/rules/sortedImports/areSpecifiersSorted.ts","../src/rules/sortedImports/getNamedSpecifiers.ts","../src/rules/sortedImports/checkSpecifiersSorting.ts","../src/rules/sortedImports/sortSpecifiersText.ts","../src/rules/sortedImports/createFix/formatNamedImport.ts","../src/rules/sortedImports/createFix/buildSortedCode.ts","../src/rules/sortedImports/createFix/findLastImportIndex.ts","../src/rules/sortedImports/createFix/getReplacementRange.ts","../src/rules/sortedImports/createFix/groupImportsByType.ts","../src/rules/sortedImports/createFix/sortImportGroups.ts","../src/rules/sortedImports/createFix/index.ts","../src/rules/sortedImports/getImportDeclarations.ts","../src/rules/sortedImports/index.ts"],"sourcesContent":["import eslint from '@eslint/js'\nimport react from 'eslint-plugin-react'\nimport reactHooks from 'eslint-plugin-react-hooks'\nimport stylistic from '@stylistic/eslint-plugin'\nimport typescript from 'typescript-eslint'\nimport {defineConfig} from 'eslint/config'\nimport {individualImports} from './rules/individualImports'\nimport {sortedImports} from './rules/sortedImports'\n\nexport const CONFIG = defineConfig([\n  {\n    ignores: [\n      'src/graphql/sdk.ts',\n      '**/node_modules/**',\n      '**/dist/**',\n    ],\n  },\n  {\n    settings: {\n      react: {\n        version: '19',\n      },\n    },\n  },\n  eslint.configs.recommended,\n  react.configs.flat.recommended,\n  stylistic.configs.recommended,\n  typescript.configs.recommended,\n  typescript.configs.stylistic,\n  {\n    plugins: {\n      'react-hooks': reactHooks,\n    },\n    rules: reactHooks.configs.recommended.rules,\n  },\n  {\n    plugins: {\n      '@borela-tech': {\n        rules: {\n          'individual-imports': individualImports,\n          'sorted-imports': sortedImports,\n        },\n      },\n    },\n    rules: {\n      '@borela-tech/individual-imports': 'error',\n      '@borela-tech/sorted-imports': 'error',\n    },\n  },\n  {\n    rules: {\n      'capitalized-comments': [\n        'error',\n        'always',\n        {ignoreConsecutiveComments: true},\n      ],\n      'react/react-in-jsx-scope': 'off',\n      '@stylistic/arrow-parens': [\n        'error',\n        'as-needed',\n      ],\n      '@stylistic/array-bracket-newline': [\n        'error',\n        'consistent',\n      ],\n      '@stylistic/array-bracket-spacing': [\n        'error',\n        'never',\n      ],\n      '@stylistic/array-element-newline': [\n        'error',\n        'consistent',\n      ],\n      '@stylistic/block-spacing': 'off',\n      '@stylistic/brace-style': [\n        'error',\n        '1tbs',\n        {allowSingleLine: true},\n      ],\n      '@stylistic/indent': [\n        'error',\n        2,\n        {ignoredNodes: ['TSMappedType > *']},\n      ],\n      '@stylistic/jsx-tag-spacing': [\n        'error',\n        {\n          afterOpening: 'never',\n          beforeClosing: 'never',\n          beforeSelfClosing: 'never',\n          closingSlash: 'never',\n        },\n      ],\n      '@stylistic/jsx-wrap-multilines': 'off',\n      '@stylistic/lines-between-class-members': 'off',\n      '@stylistic/object-curly-newline': [\n        'error',\n        {consistent: true},\n      ],\n      '@stylistic/object-curly-spacing': [\n        'error',\n        'never',\n      ],\n      '@stylistic/operator-linebreak': [\n        'error',\n        'before',\n        {overrides: {'=': 'after'}},\n      ],\n      '@stylistic/quotes': [\n        'error',\n        'single',\n        {avoidEscape: true},\n      ],\n      '@stylistic/quote-props': [\n        'error',\n        'as-needed',\n      ],\n      '@stylistic/semi': [\n        'error',\n        'never',\n        {beforeStatementContinuationChars: 'always'},\n      ],\n      '@typescript-eslint/no-empty-function': 'off',\n      '@typescript-eslint/consistent-indexed-object-style': 'off',\n    },\n  },\n])\n","import type {Rule} from 'eslint'\n\nexport const individualImports: Rule.RuleModule = {\n  meta: {\n    docs: {\n      description: 'Enforce individual imports instead of grouped imports',\n      recommended: true,\n    },\n    fixable: 'code',\n    messages: {\n      individualImports: 'Use individual imports instead of grouped imports.',\n    },\n    schema: [],\n    type: 'suggestion',\n  },\n  create(context) {\n    return {\n      ImportDeclaration(node) {\n        if (node.specifiers.length <= 1)\n          return\n        context.report({\n          node,\n          messageId: 'individualImports',\n          fix(fixer) {\n            const source = node.source.raw\n            const specifiers = node.specifiers\n              .map(importSpecifier => {\n                if (importSpecifier.type === 'ImportSpecifier')\n                  return `import {${importSpecifier.local.name}} from ${source}`\n                return null\n              })\n              .filter(Boolean)\n\n            if (specifiers.length !== node.specifiers.length)\n              return null\n\n            return fixer.replaceText(\n              node,\n              specifiers.join('\\n'),\n            )\n          },\n        })\n      },\n    }\n  },\n}\n","import type {ImportDeclaration} from 'estree'\nimport type {ImportGroup} from './ImportGroup'\n\nexport function categorizeImport(declaration: ImportDeclaration): ImportGroup {\n  if (declaration.specifiers.length === 0)\n    return 'side-effect'\n\n  if (declaration.specifiers.some(s => s.type === 'ImportDefaultSpecifier'))\n    return 'default'\n\n  return 'named'\n}\n","import type {ImportDeclaration} from 'estree'\nimport type {ImportDefaultSpecifier} from 'estree'\nimport {categorizeImport} from './categorizeImport'\n\nexport function getSortKey(declaration: ImportDeclaration): string {\n  const group = categorizeImport(declaration)\n\n  if (group === 'side-effect')\n    return (declaration.source.value as string).toLowerCase()\n\n  if (group === 'default') {\n    const defaultSpecifier = declaration.specifiers.find(\n      s => s.type === 'ImportDefaultSpecifier',\n    ) as ImportDefaultSpecifier | undefined\n\n    return defaultSpecifier?.local.name.toLowerCase() ?? ''\n  }\n\n  return ''\n}\n","import type {ImportDeclaration} from 'estree'\nimport type {CategorizedImport} from './CategorizedImport'\nimport {categorizeImport} from './categorizeImport'\nimport {getSortKey} from './getSortKey'\n\nexport function categorizeImports(declarations: ImportDeclaration[]): CategorizedImport[] {\n  return declarations.map(declaration => ({\n    declaration,\n    group: categorizeImport(declaration),\n    sortKey: getSortKey(declaration),\n  }))\n}\n","import type {CategorizedImport} from './CategorizedImport'\nimport type {ImportError} from './ImportError'\nimport type {ImportGroup} from './ImportGroup'\n\nexport function checkAlphabeticalSorting(categorized: CategorizedImport[]): ImportError[] {\n  const errors: ImportError[] = []\n\n  for (const group of ['side-effect', 'default'] as ImportGroup[]) {\n    const groupImports = categorized.filter(c => c.group === group)\n    const sorted = [...groupImports].sort((a, b) => a.sortKey.localeCompare(b.sortKey))\n    for (let i = 0; i < groupImports.length; i++) {\n      if (groupImports[i] !== sorted[i]) {\n        errors.push({\n          node: groupImports[i].declaration,\n          messageId: 'sortedImports',\n        })\n      }\n    }\n  }\n\n  return errors\n}\n","import type {CategorizedImport} from './CategorizedImport'\nimport type {ImportError} from './ImportError'\nimport type {ImportGroup} from './ImportGroup'\n\nexport function checkGroupOrdering(categorized: CategorizedImport[]): ImportError[] {\n  const groupOrder: ImportGroup[] = ['side-effect', 'default', 'named']\n  const errors: ImportError[] = []\n\n  let currentGroupIndex = -1\n  for (const {declaration, group} of categorized) {\n    const groupIndex = groupOrder.indexOf(group)\n    if (groupIndex < currentGroupIndex) {\n      errors.push({\n        node: declaration,\n        messageId: 'wrongGroup',\n      })\n    } else\n      currentGroupIndex = groupIndex\n  }\n\n  return errors\n}\n","import type {ImportSpecifier} from 'estree'\n\nexport function getSpecifierName(specifier: ImportSpecifier): string {\n  return specifier.imported.type === 'Identifier'\n    ? specifier.imported.name\n    : String(specifier.imported.value)\n}\n","import type {ImportSpecifier} from 'estree'\nimport {getSpecifierName} from './getSpecifierName'\n\nexport function areSpecifiersSorted(specifiers: ImportSpecifier[]): boolean {\n  const names = specifiers.map(s => getSpecifierName(s))\n  const sorted = [...names].sort((a, b) =>\n    a.toLowerCase().localeCompare(b.toLowerCase()),\n  )\n  return names.every((name, i) => name === sorted[i])\n}\n","import type {ImportDeclaration} from 'estree'\nimport type {ImportSpecifier} from 'estree'\n\nexport function getNamedSpecifiers(declaration: ImportDeclaration): ImportSpecifier[] {\n  return declaration.specifiers.filter(\n    (s): s is ImportSpecifier => s.type === 'ImportSpecifier',\n  )\n}\n","import type {CategorizedImport} from './CategorizedImport'\nimport type {ImportError} from './ImportError'\nimport {areSpecifiersSorted} from './areSpecifiersSorted'\nimport {getNamedSpecifiers} from './getNamedSpecifiers'\n\nexport function checkSpecifiersSorting(categorized: CategorizedImport[]): ImportError[] {\n  const errors: ImportError[] = []\n  const namedImports = categorized.filter(c => c.group === 'named')\n\n  for (const {declaration} of namedImports) {\n    const specifiers = getNamedSpecifiers(declaration)\n    if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {\n      errors.push({\n        node: declaration,\n        messageId: 'sortedNames',\n      })\n    }\n  }\n\n  return errors\n}\n","import type {ImportSpecifier} from 'estree'\nimport {getSpecifierName} from './getSpecifierName'\n\nexport function sortSpecifiersText(\n  specifiers: ImportSpecifier[],\n  sourceCode: {getText: (node: ImportSpecifier) => string},\n): string {\n  const sorted = [...specifiers].sort((a, b) => {\n    const lowerA = getSpecifierName(a).toLowerCase()\n    const lowerB = getSpecifierName(b).toLowerCase()\n    return lowerA.localeCompare(lowerB)\n  })\n  return sorted.map(s => sourceCode.getText(s)).join(', ')\n}\n","import type {ImportDeclaration} from 'estree'\nimport {areSpecifiersSorted} from '../areSpecifiersSorted'\nimport {getNamedSpecifiers} from '../getNamedSpecifiers'\nimport {sortSpecifiersText} from '../sortSpecifiersText'\n\nexport function formatNamedImport(\n  declaration: ImportDeclaration,\n  sourceCode: {getText: (node?: unknown) => string},\n): string {\n  const specifiers = getNamedSpecifiers(declaration)\n\n  if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {\n    const importText = sourceCode.getText(declaration)\n    const specifiersStart = importText.indexOf('{')\n    const specifiersEnd = importText.lastIndexOf('}')\n    const before = importText.substring(0, specifiersStart + 1)\n    const after = importText.substring(specifiersEnd)\n    const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode)\n    return before + ' ' + sortedSpecifiers + ' ' + after\n  }\n\n  return sourceCode.getText(declaration)\n}\n","import type {CategorizedImport} from '../CategorizedImport'\nimport type {ImportGroup} from '../ImportGroup'\nimport {formatNamedImport} from './formatNamedImport'\n\nexport function buildSortedCode(\n  grouped: Record<ImportGroup, CategorizedImport[]>,\n  sourceCode: {getText: (node?: unknown) => string},\n): string[] {\n  const groupOrder: ImportGroup[] = ['side-effect', 'default', 'named']\n  const sortedCode: string[] = []\n\n  for (const group of groupOrder) {\n    for (const {declaration} of grouped[group]) {\n      if (group === 'named')\n        sortedCode.push(formatNamedImport(declaration, sourceCode))\n      else\n        sortedCode.push(sourceCode.getText(declaration))\n    }\n  }\n\n  return sortedCode\n}\n","import type {Program} from 'estree'\n\nexport function findLastImportIndex(programBody: Program['body']): number {\n  let lastIndex = 0\n  for (let i = 0; i < programBody.length; i++) {\n    if (programBody[i].type === 'ImportDeclaration')\n      lastIndex = i\n    else\n      break\n  }\n  return lastIndex\n}\n","import type {ImportDeclaration} from 'estree'\nimport type {Program} from 'estree'\nimport type {ReplacementRange} from './ReplacementRange'\nimport {findLastImportIndex} from './findLastImportIndex'\n\nexport function getReplacementRange(\n  programBody: Program['body'],\n  sourceCode: {getText: () => string},\n): ReplacementRange {\n  const fullText = sourceCode.getText()\n  const lastIndex = findLastImportIndex(programBody)\n  const firstImport = programBody[0] as ImportDeclaration\n  const lastImport = programBody[lastIndex] as ImportDeclaration\n  const start = firstImport.range![0]\n  let end = lastImport.range![1]\n\n  for (let i = end; i < fullText.length; i++) {\n    const char = fullText[i]\n    if (char === '\\n' || char === ' ' || char === '\\t')\n      end++\n    else\n      break\n  }\n\n  return {start, end}\n}\n","import type {CategorizedImport} from '../CategorizedImport'\nimport type {ImportGroup} from '../ImportGroup'\n\nexport function groupImportsByType(\n  categorized: CategorizedImport[],\n): Record<ImportGroup, CategorizedImport[]> {\n  const grouped: Record<ImportGroup, CategorizedImport[]> = {\n    'side-effect': [],\n    default: [],\n    named: [],\n  }\n\n  for (const item of categorized)\n    grouped[item.group].push(item)\n\n  return grouped\n}\n","import type {CategorizedImport} from '../CategorizedImport'\nimport type {ImportGroup} from '../ImportGroup'\n\nexport function sortImportGroups(\n  grouped: Record<ImportGroup, CategorizedImport[]>,\n): void {\n  grouped['side-effect'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))\n  grouped['default'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))\n}\n","import type {Rule} from 'eslint'\nimport type {ImportDeclaration} from 'estree'\nimport type {Program} from 'estree'\nimport {buildSortedCode} from './buildSortedCode'\nimport {categorizeImports} from '../categorizeImports'\nimport {getReplacementRange} from './getReplacementRange'\nimport {groupImportsByType} from './groupImportsByType'\nimport {sortImportGroups} from './sortImportGroups'\n\nexport function createFix(\n  fixer: Rule.RuleFixer,\n  importDeclarations: ImportDeclaration[],\n  sourceCode: {getText: (node?: unknown) => string},\n  programBody: Program['body'],\n) {\n  const range = getReplacementRange(programBody, sourceCode)\n  const categorized = categorizeImports(importDeclarations)\n  const grouped = groupImportsByType(categorized)\n\n  sortImportGroups(grouped)\n\n  const sortedCode = buildSortedCode(grouped, sourceCode)\n    .join('\\n')\n\n  return fixer.replaceTextRange(\n    [range.start, range.end],\n    sortedCode,\n  )\n}\n","import type {ImportDeclaration} from 'estree'\nimport type {Program} from 'estree'\n\nexport function getImportDeclarations(programBody: Program['body']): ImportDeclaration[] {\n  return programBody.filter(\n    (statement): statement is ImportDeclaration =>\n      statement.type === 'ImportDeclaration',\n  )\n}\n","import type {Rule} from 'eslint'\nimport type {ImportError} from './ImportError'\nimport {categorizeImports} from './categorizeImports'\nimport {checkAlphabeticalSorting} from './checkAlphabeticalSorting'\nimport {checkGroupOrdering} from './checkGroupOrdering'\nimport {checkSpecifiersSorting} from './checkSpecifiersSorting'\nimport {createFix} from './createFix'\nimport {getImportDeclarations} from './getImportDeclarations'\n\nexport const sortedImports: Rule.RuleModule = {\n  meta: {\n    docs: {\n      description: 'Enforce sorted imports alphabetically',\n      recommended: true,\n    },\n    fixable: 'code',\n    messages: {\n      sortedImports: 'Imports should be sorted alphabetically',\n      sortedNames: 'Named imports should be sorted alphabetically',\n      wrongGroup: 'Import is in wrong group',\n    },\n    schema: [],\n    type: 'suggestion',\n  },\n  create(context) {\n    return {\n      Program(node) {\n        const declarations = getImportDeclarations(node.body)\n        if (declarations.length === 0)\n          return\n\n        const categorized = categorizeImports(declarations)\n        const errors: ImportError[] = [\n          ...checkGroupOrdering(categorized),\n          ...checkAlphabeticalSorting(categorized),\n          ...checkSpecifiersSorting(categorized),\n        ]\n\n        for (const error of errors) {\n          context.report({\n            node: error.node,\n            messageId: error.messageId,\n            fix(fixer) {\n              const sourceCode = context.sourceCode\n              return createFix(fixer, declarations, sourceCode, node.body)\n            },\n          })\n        }\n      },\n    }\n  },\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borela-tech/eslint-config",
-  "version": "1.3.3",
+  "version": "2.0.0",
   "description": "ESLint config used in Borela Tech projects.",
   "type": "module",
   "main": "src/index.ts",
@@ -31,7 +31,7 @@
     "@stylistic/eslint-plugin": "^4.2.0",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
-    "typescript-eslint": "^8.29.1"
+    "typescript-eslint": "8.56.0"
   },
   "devDependencies": {
     "eslint": "^9.24.0",

package/src/index.ts

@@ -3,14 +3,19 @@ import react from 'eslint-plugin-react'
 import reactHooks from 'eslint-plugin-react-hooks'
 import stylistic from '@stylistic/eslint-plugin'
 import typescript from 'typescript-eslint'
+import {defineConfig} from 'eslint/config'
+import {individualImports} from './rules/individualImports'
+import {sortedImports} from './rules/sortedImports'
 
-export const CONFIG = typescript.config(
+export const CONFIG = defineConfig([
   {
     ignores: [
       'src/graphql/sdk.ts',
       '**/node_modules/**',
       '**/dist/**',
     ],
+  },
+  {
     settings: {
       react: {
         version: '19',
@@ -28,6 +33,20 @@ export const CONFIG = typescript.config(
     },
     rules: reactHooks.configs.recommended.rules,
   },
+  {
+    plugins: {
+      '@borela-tech': {
+        rules: {
+          'individual-imports': individualImports,
+          'sorted-imports': sortedImports,
+        },
+      },
+    },
+    rules: {
+      '@borela-tech/individual-imports': 'error',
+      '@borela-tech/sorted-imports': 'error',
+    },
+  },
   {
     rules: {
       'capitalized-comments': [
@@ -103,20 +122,6 @@ export const CONFIG = typescript.config(
       ],
       '@typescript-eslint/no-empty-function': 'off',
       '@typescript-eslint/consistent-indexed-object-style': 'off',
-      'sort-imports': [
-        'error',
-        {
-          allowSeparatedGroups: true,
-          ignoreCase: true,
-          ignoreMemberSort: false,
-          memberSyntaxSortOrder: [
-            'none',
-            'all',
-            'single',
-            'multiple',
-          ],
-        },
-      ],
     },
   },
-)
+])

package/src/rules/__tests__/dedent/countLeadingSpaces.ts

@@ -0,0 +1,4 @@
+export function countLeadingSpaces(line: string): number {
+  const match = line.match(/^(\s*)/)
+  return match ? match[1].length : 0
+}

package/src/rules/__tests__/dedent/findMinIndent.ts

@@ -0,0 +1,7 @@
+import {countLeadingSpaces} from './countLeadingSpaces'
+
+export function findMinIndent(lines: string[]): number {
+  const nonEmptyLines = lines.filter(line => line.trim().length > 0)
+  const indents = nonEmptyLines.map(line => countLeadingSpaces(line))
+  return Math.min(...indents)
+}

package/src/rules/__tests__/dedent/index.ts

@@ -0,0 +1,17 @@
+import {findMinIndent} from './findMinIndent'
+import {interpolate} from './interpolate'
+import {removeEmptyPrefix} from './removeEmptyPrefix'
+import {removeEmptySuffix} from './removeEmptySuffix'
+import {removeIndent} from './removeIndent'
+
+export function dedent(
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): string {
+  const raw = interpolate(strings, values)
+  const lines = raw.split('\n')
+  const withoutPrefix = removeEmptyPrefix(lines)
+  const trimmed = removeEmptySuffix(withoutPrefix)
+  const indentSize = findMinIndent(trimmed)
+  return removeIndent(trimmed, indentSize)
+}

package/src/rules/__tests__/dedent/interpolate.ts

@@ -0,0 +1,11 @@
+export function interpolate(
+  strings: TemplateStringsArray,
+  values: unknown[],
+): string {
+  let result = ''
+  for (let i = 0; i < strings.length; i++) {
+    result += strings[i]
+    if (i < values.length) result += String(values[i])
+  }
+  return result
+}

package/src/rules/__tests__/dedent/removeEmptyPrefix.ts

@@ -0,0 +1,6 @@
+export function removeEmptyPrefix(lines: string[]): string[] {
+  const copy = [...lines]
+  while (copy.length > 0 && copy[0].trim() === '')
+    copy.shift()
+  return copy
+}

package/src/rules/__tests__/dedent/removeEmptySuffix.ts

@@ -0,0 +1,6 @@
+export function removeEmptySuffix(lines: string[]): string[] {
+  const copy = [...lines]
+  while (copy.length > 0 && copy[copy.length - 1].trim() === '')
+    copy.pop()
+  return copy
+}

package/src/rules/__tests__/dedent/removeIndent.ts

@@ -0,0 +1,3 @@
+export function removeIndent(lines: string[], indentSize: number): string {
+  return lines.map(line => line.slice(indentSize)).join('\n')
+}

package/src/rules/__tests__/individualImports.test.ts

@@ -0,0 +1,42 @@
+import typescript from 'typescript-eslint'
+import {RuleTester} from 'eslint'
+import {individualImports} from '../individualImports'
+import {dedent} from './dedent'
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: typescript.parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+})
+
+ruleTester.run('individual-imports', individualImports, {
+  valid: [{
+    code: "import {foo} from 'bar'",
+  }, {
+    code: "import foo from 'bar'",
+  }, {
+    code: "import * as foo from 'bar'",
+  }, {
+    code: "import 'bar'",
+  }],
+  invalid: [{
+    code: "import {foo, bar} from 'baz'",
+    errors: [{messageId: 'individualImports'}],
+    output: dedent`
+      import {foo} from 'baz'
+      import {bar} from 'baz'
+    `,
+  }, {
+    code: "import {foo, bar, baz} from 'qux'",
+    errors: [{messageId: 'individualImports'}],
+    output: dedent`
+      import {foo} from 'qux'
+      import {bar} from 'qux'
+      import {baz} from 'qux'
+    `,
+  }],
+})

package/src/rules/__tests__/sortedImports.test.ts

@@ -0,0 +1,114 @@
+import typescript from 'typescript-eslint'
+import {RuleTester} from 'eslint'
+import {sortedImports} from '../sortedImports'
+import {dedent} from './dedent'
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: typescript.parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+})
+
+ruleTester.run('sorted-imports', sortedImports, {
+  valid: [{
+    code: "import {foo} from 'bar'",
+  }, {
+    code: "import foo from 'bar'",
+  }, {
+    code: "import 'bar'",
+  }, {
+    code: dedent`
+      import 'aaa'
+      import 'bbb'
+      import bar from 'bbb'
+      import foo from 'aaa'
+      import {a} from 'aaa'
+      import {b} from 'bbb'
+    `,
+  }, {
+    code: dedent`
+      import {a} from 'ccc'
+      import {b} from 'aaa'
+      import {c} from 'bbb'
+    `,
+  }, {
+    code: dedent`
+      import {a, b, c} from 'bar'
+    `,
+  }, {
+    code: '',
+  }, {
+    code: 'const x = 1',
+  }],
+  invalid: [{
+    code: dedent`
+      import {c, a, b} from 'bar'
+    `,
+    errors: [{messageId: 'sortedNames'}],
+    output: dedent`
+      import { a, b, c } from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {z, a} from 'bar'
+    `,
+    errors: [{messageId: 'sortedNames'}],
+    output: dedent`
+      import { a, z } from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import foo from 'aaa'
+      import bar from 'bbb'
+    `,
+    errors: [{messageId: 'sortedImports'}, {messageId: 'sortedImports'}],
+    output: dedent`
+      import bar from 'bbb'
+      import foo from 'aaa'
+    `,
+  }, {
+    code: dedent`
+      import 'bbb'
+      import 'aaa'
+    `,
+    errors: [{messageId: 'sortedImports'}, {messageId: 'sortedImports'}],
+    output: dedent`
+      import 'aaa'
+      import 'bbb'
+    `,
+  }, {
+    code: dedent`
+      import foo from 'bar'
+      import 'baz'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      import 'baz'
+      import foo from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {a} from 'bar'
+      import foo from 'baz'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      import foo from 'baz'
+      import {a} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {b, a} from 'bar'
+      import foo from 'baz'
+    `,
+    errors: [{messageId: 'sortedNames'}, {messageId: 'wrongGroup'}],
+    output: dedent`
+      import foo from 'baz'
+      import { a, b } from 'bar'
+    `,
+  }],
+})

package/src/rules/individualImports.ts

@@ -24,9 +24,9 @@ export const individualImports: Rule.RuleModule = {
           fix(fixer) {
             const source = node.source.raw
             const specifiers = node.specifiers
-              .map(specifier => {
-                if (specifier.type === 'ImportSpecifier')
-                  return `import {${specifier.local.name}} from ${source}`
+              .map(importSpecifier => {
+                if (importSpecifier.type === 'ImportSpecifier')
+                  return `import {${importSpecifier.local.name}} from ${source}`
                 return null
               })
               .filter(Boolean)

package/src/rules/sortedImports/CategorizedImport.ts

@@ -0,0 +1,8 @@
+import type {ImportDeclaration} from 'estree'
+import type {ImportGroup} from './ImportGroup'
+
+export interface CategorizedImport {
+  declaration: ImportDeclaration
+  group: ImportGroup
+  sortKey: string
+}

package/src/rules/sortedImports/ImportError.ts

@@ -0,0 +1,6 @@
+import type {ImportDeclaration} from 'estree'
+
+export interface ImportError {
+  node: ImportDeclaration
+  messageId: 'sortedImports' | 'sortedNames' | 'wrongGroup'
+}

package/src/rules/sortedImports/ImportGroup.ts

@@ -0,0 +1 @@
+export type ImportGroup = 'side-effect' | 'default' | 'named'

package/src/rules/sortedImports/areSpecifiersSorted.ts

@@ -0,0 +1,10 @@
+import type {ImportSpecifier} from 'estree'
+import {getSpecifierName} from './getSpecifierName'
+
+export function areSpecifiersSorted(specifiers: ImportSpecifier[]): boolean {
+  const names = specifiers.map(s => getSpecifierName(s))
+  const sorted = [...names].sort((a, b) =>
+    a.toLowerCase().localeCompare(b.toLowerCase()),
+  )
+  return names.every((name, i) => name === sorted[i])
+}

package/src/rules/sortedImports/categorizeImport.ts

@@ -0,0 +1,12 @@
+import type {ImportDeclaration} from 'estree'
+import type {ImportGroup} from './ImportGroup'
+
+export function categorizeImport(declaration: ImportDeclaration): ImportGroup {
+  if (declaration.specifiers.length === 0)
+    return 'side-effect'
+
+  if (declaration.specifiers.some(s => s.type === 'ImportDefaultSpecifier'))
+    return 'default'
+
+  return 'named'
+}

package/src/rules/sortedImports/categorizeImports.ts

@@ -0,0 +1,12 @@
+import type {ImportDeclaration} from 'estree'
+import type {CategorizedImport} from './CategorizedImport'
+import {categorizeImport} from './categorizeImport'
+import {getSortKey} from './getSortKey'
+
+export function categorizeImports(declarations: ImportDeclaration[]): CategorizedImport[] {
+  return declarations.map(declaration => ({
+    declaration,
+    group: categorizeImport(declaration),
+    sortKey: getSortKey(declaration),
+  }))
+}

package/src/rules/sortedImports/checkAlphabeticalSorting.ts

@@ -0,0 +1,22 @@
+import type {CategorizedImport} from './CategorizedImport'
+import type {ImportError} from './ImportError'
+import type {ImportGroup} from './ImportGroup'
+
+export function checkAlphabeticalSorting(categorized: CategorizedImport[]): ImportError[] {
+  const errors: ImportError[] = []
+
+  for (const group of ['side-effect', 'default'] as ImportGroup[]) {
+    const groupImports = categorized.filter(c => c.group === group)
+    const sorted = [...groupImports].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+    for (let i = 0; i < groupImports.length; i++) {
+      if (groupImports[i] !== sorted[i]) {
+        errors.push({
+          node: groupImports[i].declaration,
+          messageId: 'sortedImports',
+        })
+      }
+    }
+  }
+
+  return errors
+}

package/src/rules/sortedImports/checkGroupOrdering.ts

@@ -0,0 +1,22 @@
+import type {CategorizedImport} from './CategorizedImport'
+import type {ImportError} from './ImportError'
+import type {ImportGroup} from './ImportGroup'
+
+export function checkGroupOrdering(categorized: CategorizedImport[]): ImportError[] {
+  const groupOrder: ImportGroup[] = ['side-effect', 'default', 'named']
+  const errors: ImportError[] = []
+
+  let currentGroupIndex = -1
+  for (const {declaration, group} of categorized) {
+    const groupIndex = groupOrder.indexOf(group)
+    if (groupIndex < currentGroupIndex) {
+      errors.push({
+        node: declaration,
+        messageId: 'wrongGroup',
+      })
+    } else
+      currentGroupIndex = groupIndex
+  }
+
+  return errors
+}

package/src/rules/sortedImports/checkSpecifiersSorting.ts

@@ -0,0 +1,21 @@
+import type {CategorizedImport} from './CategorizedImport'
+import type {ImportError} from './ImportError'
+import {areSpecifiersSorted} from './areSpecifiersSorted'
+import {getNamedSpecifiers} from './getNamedSpecifiers'
+
+export function checkSpecifiersSorting(categorized: CategorizedImport[]): ImportError[] {
+  const errors: ImportError[] = []
+  const namedImports = categorized.filter(c => c.group === 'named')
+
+  for (const {declaration} of namedImports) {
+    const specifiers = getNamedSpecifiers(declaration)
+    if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+      errors.push({
+        node: declaration,
+        messageId: 'sortedNames',
+      })
+    }
+  }
+
+  return errors
+}

package/src/rules/sortedImports/createFix/ReplacementRange.ts

@@ -0,0 +1,4 @@
+export interface ReplacementRange {
+  start: number
+  end: number
+}

package/src/rules/sortedImports/createFix/buildSortedCode.ts

@@ -0,0 +1,22 @@
+import type {CategorizedImport} from '../CategorizedImport'
+import type {ImportGroup} from '../ImportGroup'
+import {formatNamedImport} from './formatNamedImport'
+
+export function buildSortedCode(
+  grouped: Record<ImportGroup, CategorizedImport[]>,
+  sourceCode: {getText: (node?: unknown) => string},
+): string[] {
+  const groupOrder: ImportGroup[] = ['side-effect', 'default', 'named']
+  const sortedCode: string[] = []
+
+  for (const group of groupOrder) {
+    for (const {declaration} of grouped[group]) {
+      if (group === 'named')
+        sortedCode.push(formatNamedImport(declaration, sourceCode))
+      else
+        sortedCode.push(sourceCode.getText(declaration))
+    }
+  }
+
+  return sortedCode
+}

package/src/rules/sortedImports/createFix/findLastImportIndex.ts

@@ -0,0 +1,12 @@
+import type {Program} from 'estree'
+
+export function findLastImportIndex(programBody: Program['body']): number {
+  let lastIndex = 0
+  for (let i = 0; i < programBody.length; i++) {
+    if (programBody[i].type === 'ImportDeclaration')
+      lastIndex = i
+    else
+      break
+  }
+  return lastIndex
+}

package/src/rules/sortedImports/createFix/formatNamedImport.ts

@@ -0,0 +1,23 @@
+import type {ImportDeclaration} from 'estree'
+import {areSpecifiersSorted} from '../areSpecifiersSorted'
+import {getNamedSpecifiers} from '../getNamedSpecifiers'
+import {sortSpecifiersText} from '../sortSpecifiersText'
+
+export function formatNamedImport(
+  declaration: ImportDeclaration,
+  sourceCode: {getText: (node?: unknown) => string},
+): string {
+  const specifiers = getNamedSpecifiers(declaration)
+
+  if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+    const importText = sourceCode.getText(declaration)
+    const specifiersStart = importText.indexOf('{')
+    const specifiersEnd = importText.lastIndexOf('}')
+    const before = importText.substring(0, specifiersStart + 1)
+    const after = importText.substring(specifiersEnd)
+    const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode)
+    return before + ' ' + sortedSpecifiers + ' ' + after
+  }
+
+  return sourceCode.getText(declaration)
+}

package/src/rules/sortedImports/createFix/getReplacementRange.ts

@@ -0,0 +1,26 @@
+import type {ImportDeclaration} from 'estree'
+import type {Program} from 'estree'
+import type {ReplacementRange} from './ReplacementRange'
+import {findLastImportIndex} from './findLastImportIndex'
+
+export function getReplacementRange(
+  programBody: Program['body'],
+  sourceCode: {getText: () => string},
+): ReplacementRange {
+  const fullText = sourceCode.getText()
+  const lastIndex = findLastImportIndex(programBody)
+  const firstImport = programBody[0] as ImportDeclaration
+  const lastImport = programBody[lastIndex] as ImportDeclaration
+  const start = firstImport.range![0]
+  let end = lastImport.range![1]
+
+  for (let i = end; i < fullText.length; i++) {
+    const char = fullText[i]
+    if (char === '\n' || char === ' ' || char === '\t')
+      end++
+    else
+      break
+  }
+
+  return {start, end}
+}

package/src/rules/sortedImports/createFix/groupImportsByType.ts

@@ -0,0 +1,17 @@
+import type {CategorizedImport} from '../CategorizedImport'
+import type {ImportGroup} from '../ImportGroup'
+
+export function groupImportsByType(
+  categorized: CategorizedImport[],
+): Record<ImportGroup, CategorizedImport[]> {
+  const grouped: Record<ImportGroup, CategorizedImport[]> = {
+    'side-effect': [],
+    default: [],
+    named: [],
+  }
+
+  for (const item of categorized)
+    grouped[item.group].push(item)
+
+  return grouped
+}

package/src/rules/sortedImports/createFix/index.ts

@@ -0,0 +1,29 @@
+import type {Rule} from 'eslint'
+import type {ImportDeclaration} from 'estree'
+import type {Program} from 'estree'
+import {buildSortedCode} from './buildSortedCode'
+import {categorizeImports} from '../categorizeImports'
+import {getReplacementRange} from './getReplacementRange'
+import {groupImportsByType} from './groupImportsByType'
+import {sortImportGroups} from './sortImportGroups'
+
+export function createFix(
+  fixer: Rule.RuleFixer,
+  importDeclarations: ImportDeclaration[],
+  sourceCode: {getText: (node?: unknown) => string},
+  programBody: Program['body'],
+) {
+  const range = getReplacementRange(programBody, sourceCode)
+  const categorized = categorizeImports(importDeclarations)
+  const grouped = groupImportsByType(categorized)
+
+  sortImportGroups(grouped)
+
+  const sortedCode = buildSortedCode(grouped, sourceCode)
+    .join('\n')
+
+  return fixer.replaceTextRange(
+    [range.start, range.end],
+    sortedCode,
+  )
+}

package/src/rules/sortedImports/createFix/sortImportGroups.ts

@@ -0,0 +1,9 @@
+import type {CategorizedImport} from '../CategorizedImport'
+import type {ImportGroup} from '../ImportGroup'
+
+export function sortImportGroups(
+  grouped: Record<ImportGroup, CategorizedImport[]>,
+): void {
+  grouped['side-effect'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+  grouped['default'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+}

package/src/rules/sortedImports/getImportDeclarations.ts

@@ -0,0 +1,9 @@
+import type {ImportDeclaration} from 'estree'
+import type {Program} from 'estree'
+
+export function getImportDeclarations(programBody: Program['body']): ImportDeclaration[] {
+  return programBody.filter(
+    (statement): statement is ImportDeclaration =>
+      statement.type === 'ImportDeclaration',
+  )
+}

package/src/rules/sortedImports/getNamedSpecifiers.ts

@@ -0,0 +1,8 @@
+import type {ImportDeclaration} from 'estree'
+import type {ImportSpecifier} from 'estree'
+
+export function getNamedSpecifiers(declaration: ImportDeclaration): ImportSpecifier[] {
+  return declaration.specifiers.filter(
+    (s): s is ImportSpecifier => s.type === 'ImportSpecifier',
+  )
+}

package/src/rules/sortedImports/getSortKey.ts

@@ -0,0 +1,20 @@
+import type {ImportDeclaration} from 'estree'
+import type {ImportDefaultSpecifier} from 'estree'
+import {categorizeImport} from './categorizeImport'
+
+export function getSortKey(declaration: ImportDeclaration): string {
+  const group = categorizeImport(declaration)
+
+  if (group === 'side-effect')
+    return (declaration.source.value as string).toLowerCase()
+
+  if (group === 'default') {
+    const defaultSpecifier = declaration.specifiers.find(
+      s => s.type === 'ImportDefaultSpecifier',
+    ) as ImportDefaultSpecifier | undefined
+
+    return defaultSpecifier?.local.name.toLowerCase() ?? ''
+  }
+
+  return ''
+}

package/src/rules/sortedImports/getSpecifierName.ts

@@ -0,0 +1,7 @@
+import type {ImportSpecifier} from 'estree'
+
+export function getSpecifierName(specifier: ImportSpecifier): string {
+  return specifier.imported.type === 'Identifier'
+    ? specifier.imported.name
+    : String(specifier.imported.value)
+}

package/src/rules/sortedImports/index.ts

@@ -0,0 +1,52 @@
+import type {Rule} from 'eslint'
+import type {ImportError} from './ImportError'
+import {categorizeImports} from './categorizeImports'
+import {checkAlphabeticalSorting} from './checkAlphabeticalSorting'
+import {checkGroupOrdering} from './checkGroupOrdering'
+import {checkSpecifiersSorting} from './checkSpecifiersSorting'
+import {createFix} from './createFix'
+import {getImportDeclarations} from './getImportDeclarations'
+
+export const sortedImports: Rule.RuleModule = {
+  meta: {
+    docs: {
+      description: 'Enforce sorted imports alphabetically',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      sortedImports: 'Imports should be sorted alphabetically',
+      sortedNames: 'Named imports should be sorted alphabetically',
+      wrongGroup: 'Import is in wrong group',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const declarations = getImportDeclarations(node.body)
+        if (declarations.length === 0)
+          return
+
+        const categorized = categorizeImports(declarations)
+        const errors: ImportError[] = [
+          ...checkGroupOrdering(categorized),
+          ...checkAlphabeticalSorting(categorized),
+          ...checkSpecifiersSorting(categorized),
+        ]
+
+        for (const error of errors) {
+          context.report({
+            node: error.node,
+            messageId: error.messageId,
+            fix(fixer) {
+              const sourceCode = context.sourceCode
+              return createFix(fixer, declarations, sourceCode, node.body)
+            },
+          })
+        }
+      },
+    }
+  },
+}

package/src/rules/sortedImports/sortSpecifiersText.ts

@@ -0,0 +1,14 @@
+import type {ImportSpecifier} from 'estree'
+import {getSpecifierName} from './getSpecifierName'
+
+export function sortSpecifiersText(
+  specifiers: ImportSpecifier[],
+  sourceCode: {getText: (node: ImportSpecifier) => string},
+): string {
+  const sorted = [...specifiers].sort((a, b) => {
+    const lowerA = getSpecifierName(a).toLowerCase()
+    const lowerB = getSpecifierName(b).toLowerCase()
+    return lowerA.localeCompare(lowerB)
+  })
+  return sorted.map(s => sourceCode.getText(s)).join(', ')
+}

package/src/rules/sortedImports.ts

@@ -1,83 +0,0 @@
-import type {ImportDeclaration} from 'estree'
-import type {Rule} from 'eslint'
-
-export const sortedImports: Rule.RuleModule = {
-  meta: {
-    docs: {
-      description: 'Enforce sorted imports alphabetically',
-      recommended: true,
-    },
-    fixable: 'code',
-    messages: {
-      sortedImports: 'Imports should be sorted alphabetically',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  create(context) {
-    return {
-      Program(node) {
-        const importDeclarations = node.body.filter(
-          (statement): statement is ImportDeclaration =>
-            statement.type === 'ImportDeclaration',
-        )
-
-        if (importDeclarations.length <= 1) return
-
-        const sortedImports = importDeclarations.sort((a, b) => {
-          const sourceA = (a.source.value as string).toLowerCase()
-          const sourceB = (b.source.value as string).toLowerCase()
-          return sourceA.localeCompare(sourceB)
-        })
-
-        const isSorted = importDeclarations.every((decl, index) => decl === sortedImports[index])
-
-        if (!isSorted) {
-          context.report({
-            node: importDeclarations[0],
-            messageId: 'sortedImports',
-            fix(fixer) {
-              const sourceCode = context.getSourceCode()
-
-              // Find all consecutive import statements at the beginning
-              const programBody = node.body
-              let lastImportIndex = 0
-              for (let i = 0; i < programBody.length; i++) {
-                if (programBody[i].type === 'ImportDeclaration') {
-                  lastImportIndex = i
-                } else {
-                  break
-                }
-              }
-
-              const firstImport = programBody[0] as import('estree').ImportDeclaration
-              const lastImport = programBody[lastImportIndex] as import('estree').ImportDeclaration
-
-              // Get the range from start of first import to end of last import
-              const startRange = firstImport.range![0]
-              let endRange = lastImport.range![1]
-
-              // Include any trailing whitespace/newlines after the last import
-              const fullText = sourceCode.getText()
-              for (let i = endRange; i < fullText.length; i++) {
-                const char = fullText[i]
-                if (char === '\n' || char === ' ' || char === '\t') {
-                  endRange++
-                } else {
-                  break
-                }
-              }
-
-              // Generate the sorted import code
-              const sortedCode = sortedImports.map(decl => {
-                return sourceCode.getText(decl)
-              }).join('\n')
-
-              return fixer.replaceTextRange([startRange, endRange], sortedCode)
-            },
-          })
-        }
-      },
-    }
-  },
-}