@borela-tech/eslint-config 2.0.0 → 2.1.0

package/dist/index.js

@@ -6,6 +6,118 @@ import stylistic from "@stylistic/eslint-plugin";
 import typescript from "typescript-eslint";
 import { defineConfig } from "eslint/config";
 
+// src/rules/importsAndReExportsAtTop/getStatementType.ts
+function getStatementType(statement) {
+  if (statement.type === "ImportDeclaration")
+    return "import";
+  if (statement.type === "ExportAllDeclaration")
+    return "re-export";
+  if (statement.type === "ExportNamedDeclaration") {
+    if (statement.source !== null)
+      return "re-export";
+  }
+  return "other";
+}
+
+// src/rules/importsAndReExportsAtTop/categorizeStatements.ts
+function categorizeStatements(statements) {
+  const result = {
+    imports: [],
+    reExports: [],
+    other: []
+  };
+  for (const statement of statements) {
+    const type = getStatementType(statement);
+    if (type === "import")
+      result.imports.push(statement);
+    else if (type === "re-export")
+      result.reExports.push(statement);
+    else
+      result.other.push(statement);
+  }
+  return result;
+}
+
+// src/rules/importsAndReExportsAtTop/findFirstIndices.ts
+function findFirstIndices(statements) {
+  let firstImport = Infinity;
+  let firstReExport = Infinity;
+  let firstOther = -1;
+  for (let i = 0; i < statements.length; i++) {
+    const type = getStatementType(statements[i]);
+    if (type === "import" && firstImport === Infinity)
+      firstImport = i;
+    else if (type === "re-export" && firstReExport === Infinity)
+      firstReExport = i;
+    else if (type === "other" && firstOther === -1)
+      firstOther = i;
+  }
+  return { firstImport, firstReExport, firstOther };
+}
+
+// src/rules/importsAndReExportsAtTop/generateSortedText.ts
+function generateSortedText(context, categories) {
+  const allStatements = [
+    ...categories.imports,
+    ...categories.reExports,
+    ...categories.other
+  ];
+  return allStatements.map(
+    (node) => context.sourceCode.getText(node)
+  ).join("\n");
+}
+
+// src/rules/importsAndReExportsAtTop/hasViolation.ts
+function hasViolation(indices, categories) {
+  const {
+    firstImport,
+    firstReExport,
+    firstOther
+  } = indices;
+  if (categories.imports.length === 0 || categories.reExports.length === 0)
+    return false;
+  const firstImportOrReExport = Math.min(firstImport, firstReExport);
+  const hasOtherBeforeImportOrReExport = firstOther !== -1 && firstOther < firstImportOrReExport;
+  if (hasOtherBeforeImportOrReExport || firstImport > firstReExport)
+    return true;
+  return false;
+}
+
+// src/rules/importsAndReExportsAtTop/index.ts
+var importsAndReExportsAtTop = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce imports and re-exports at the top of the file",
+      recommended: false
+    },
+    fixable: "code",
+    messages: {
+      importsAndReExportsAtTop: "Imports and re-exports should be at the top of the file."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const statements = node.body;
+        const categories = categorizeStatements(statements);
+        const indices = findFirstIndices(statements);
+        if (!hasViolation(indices, categories))
+          return;
+        context.report({
+          node,
+          messageId: "importsAndReExportsAtTop",
+          fix(fixer) {
+            const sortedText = generateSortedText(context, categories);
+            return fixer.replaceText(node, sortedText);
+          }
+        });
+      }
+    };
+  }
+};
+
 // src/rules/individualImports.ts
 var individualImports = {
   meta: {
@@ -30,17 +142,48 @@ var individualImports = {
           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")
-            );
+            const specifiers = node.specifiers.filter((s) => s.type === "ImportSpecifier").map((s) => `import {${s.local.name}} from ${source}`).join("\n");
+            return fixer.replaceText(node, specifiers);
+          }
+        });
+      }
+    };
+  }
+};
+
+// src/rules/individualReExports.ts
+var individualReExports = {
+  meta: {
+    docs: {
+      description: "Enforce individual exports instead of grouped exports",
+      recommended: true
+    },
+    fixable: "code",
+    messages: {
+      individualReExports: "Use individual exports instead of grouped exports."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  create(context) {
+    return {
+      ExportNamedDeclaration(node) {
+        const exportNode = node;
+        if (!exportNode.source || exportNode.specifiers.length <= 1)
+          return;
+        context.report({
+          node,
+          messageId: "individualReExports",
+          fix(fixer) {
+            const source = exportNode.source.value;
+            const typeKeyword = exportNode.exportKind === "type" ? "type " : "";
+            const specifiers = exportNode.specifiers.map((s) => {
+              const localName = s.local.type === "Identifier" ? s.local.name : s.local.value;
+              const exportedName = s.exported.type === "Identifier" ? s.exported.name : s.exported.value;
+              const name = localName === exportedName ? localName : `${localName} as ${exportedName}`;
+              return `export ${typeKeyword}{${name}} from '${source}'`;
+            }).join("\n");
+            return fixer.replaceText(node, specifiers);
           }
         });
       }
@@ -50,6 +193,8 @@ var individualImports = {
 
 // src/rules/sortedImports/categorizeImport.ts
 function categorizeImport(declaration) {
+  if (declaration.importKind === "type")
+    return "type";
   if (declaration.specifiers.length === 0)
     return "side-effect";
   if (declaration.specifiers.some((s) => s.type === "ImportDefaultSpecifier"))
@@ -61,14 +206,15 @@ function categorizeImport(declaration) {
 function getSortKey(declaration) {
   const group = categorizeImport(declaration);
   if (group === "side-effect")
-    return declaration.source.value.toLowerCase();
+    return declaration.source.value;
   if (group === "default") {
     const defaultSpecifier = declaration.specifiers.find(
       (s) => s.type === "ImportDefaultSpecifier"
     );
-    return defaultSpecifier?.local.name.toLowerCase() ?? "";
+    return defaultSpecifier?.local.name ?? "";
   }
-  return "";
+  const specifier = declaration.specifiers[0];
+  return specifier.local.name;
 }
 
 // src/rules/sortedImports/categorizeImports.ts
@@ -80,12 +226,25 @@ function categorizeImports(declarations) {
   }));
 }
 
+// src/lib/compare.ts
+function compare(a, b) {
+  return a.localeCompare(b, "en", { sensitivity: "case" });
+}
+
+// src/rules/sortedImports/ImportGroupOrder.ts
+var importGroupOrder = [
+  "side-effect",
+  "default",
+  "named",
+  "type"
+];
+
 // src/rules/sortedImports/checkAlphabeticalSorting.ts
 function checkAlphabeticalSorting(categorized) {
   const errors = [];
-  for (const group of ["side-effect", "default"]) {
+  for (const group of importGroupOrder) {
     const groupImports = categorized.filter((c) => c.group === group);
-    const sorted = [...groupImports].sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+    const sorted = [...groupImports].sort((a, b) => compare(a.sortKey, b.sortKey));
     for (let i = 0; i < groupImports.length; i++) {
       if (groupImports[i] !== sorted[i]) {
         errors.push({
@@ -100,11 +259,10 @@ function checkAlphabeticalSorting(categorized) {
 
 // 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);
+    const groupIndex = importGroupOrder.indexOf(group);
     if (groupIndex < currentGroupIndex) {
       errors.push({
         node: declaration,
@@ -124,9 +282,7 @@ function getSpecifierName(specifier) {
 // 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())
-  );
+  const sorted = [...names].sort((a, b) => compare(a, b));
   return names.every((name, i) => name === sorted[i]);
 }
 
@@ -156,9 +312,9 @@ function checkSpecifiersSorting(categorized) {
 // 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);
+    const nameA = getSpecifierName(a);
+    const nameB = getSpecifierName(b);
+    return compare(nameA, nameB);
   });
   return sorted.map((s) => sourceCode.getText(s)).join(", ");
 }
@@ -167,24 +323,20 @@ function sortSpecifiersText(specifiers, sourceCode) {
 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;
+    const source = declaration.source.value;
+    const prefix = declaration.importKind === "type" ? "import type " : "import ";
+    return `${prefix}{${sortedSpecifiers}} from '${source}'`;
   }
   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 group of importGroupOrder) {
     for (const { declaration } of grouped[group]) {
-      if (group === "named")
+      if (group === "named" || group === "type")
         sortedCode.push(formatNamedImport(declaration, sourceCode));
       else
         sortedCode.push(sourceCode.getText(declaration));
@@ -206,20 +358,12 @@ function findLastImportIndex(programBody) {
 }
 
 // src/rules/sortedImports/createFix/getReplacementRange.ts
-function getReplacementRange(programBody, sourceCode) {
-  const fullText = sourceCode.getText();
+function getReplacementRange(programBody) {
   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;
-  }
+  const end = lastImport.range[1];
   return { start, end };
 }
 
@@ -228,7 +372,8 @@ function groupImportsByType(categorized) {
   const grouped = {
     "side-effect": [],
     default: [],
-    named: []
+    named: [],
+    type: []
   };
   for (const item of categorized)
     grouped[item.group].push(item);
@@ -237,13 +382,15 @@ function groupImportsByType(categorized) {
 
 // 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));
+  grouped["side-effect"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  grouped["default"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  grouped["named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  grouped["type"].sort((a, b) => compare(a.sortKey, b.sortKey));
 }
 
 // src/rules/sortedImports/createFix/index.ts
 function createFix(fixer, importDeclarations, sourceCode, programBody) {
-  const range = getReplacementRange(programBody, sourceCode);
+  const range = getReplacementRange(programBody);
   const categorized = categorizeImports(importDeclarations);
   const grouped = groupImportsByType(categorized);
   sortImportGroups(grouped);
@@ -280,7 +427,8 @@ var sortedImports = {
   create(context) {
     return {
       Program(node) {
-        const declarations = getImportDeclarations(node.body);
+        const body = node.body;
+        const declarations = getImportDeclarations(body);
         if (declarations.length === 0)
           return;
         const categorized = categorizeImports(declarations);
@@ -295,7 +443,280 @@ var sortedImports = {
             messageId: error.messageId,
             fix(fixer) {
               const sourceCode = context.sourceCode;
-              return createFix(fixer, declarations, sourceCode, node.body);
+              return createFix(fixer, declarations, sourceCode, body);
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/sortedReExports/categorizeReExport.ts
+function categorizeReExport(declaration) {
+  if (declaration.type === "ExportAllDeclaration")
+    return "re-export-all";
+  if (declaration.exportKind === "type")
+    return "re-export-type";
+  return "re-export-named";
+}
+
+// src/rules/sortedReExports/getSortKey.ts
+function getSortKey2(declaration) {
+  if (declaration.type === "ExportAllDeclaration")
+    return declaration.source.value;
+  const specifier = declaration.specifiers[0];
+  if (!specifier)
+    return "";
+  return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
+}
+
+// src/rules/sortedReExports/categorizeReExports.ts
+function categorizeReExports(declarations) {
+  return declarations.map((declaration) => {
+    return {
+      declaration,
+      group: categorizeReExport(declaration),
+      sortKey: getSortKey2(declaration)
+    };
+  });
+}
+
+// src/rules/sortedReExports/ReExportGroupOrder.ts
+var reExportGroupOrder = [
+  "re-export-all",
+  "re-export-named",
+  "re-export-type"
+];
+
+// src/rules/sortedReExports/checkAlphabeticalSorting.ts
+function checkAlphabeticalSorting2(categorized) {
+  const errors = [];
+  for (const group of reExportGroupOrder) {
+    const groupReExports = categorized.filter((c) => c.group === group);
+    const sorted = [...groupReExports].sort(
+      (a, b) => compare(a.sortKey, b.sortKey)
+    );
+    for (let i = 0; i < groupReExports.length; i++) {
+      if (groupReExports[i] !== sorted[i]) {
+        errors.push({
+          node: groupReExports[i].declaration,
+          messageId: "sortedReExports"
+        });
+      }
+    }
+  }
+  return errors;
+}
+
+// src/rules/sortedReExports/checkGroupOrdering.ts
+function checkGroupOrdering2(categorized) {
+  const errors = [];
+  let currentGroupIndex = -1;
+  for (const { declaration, group } of categorized) {
+    const groupIndex = reExportGroupOrder.indexOf(group);
+    if (groupIndex < currentGroupIndex) {
+      errors.push({
+        node: declaration,
+        messageId: "wrongGroup"
+      });
+    } else
+      currentGroupIndex = groupIndex;
+  }
+  return errors;
+}
+
+// src/rules/sortedReExports/getSpecifierName.ts
+function getSpecifierName2(specifier) {
+  return specifier.local.type === "Identifier" ? specifier.local.name : String(specifier.local.value);
+}
+
+// src/rules/sortedReExports/areSpecifiersSorted.ts
+function areSpecifiersSorted2(specifiers) {
+  const names = specifiers.map((s) => getSpecifierName2(s));
+  const sorted = [...names].sort((a, b) => compare(a, b));
+  return names.every((name, i) => name === sorted[i]);
+}
+
+// src/rules/sortedReExports/getNamedSpecifiers.ts
+function getNamedSpecifiers2(declaration) {
+  return declaration.specifiers.filter(
+    (s) => s.type === "ExportSpecifier" && s.local.type === "Identifier"
+  );
+}
+
+// src/rules/sortedReExports/isNamedReExport.ts
+function isNamedReExport(x) {
+  return x.group !== "re-export-all";
+}
+
+// src/rules/sortedReExports/checkSpecifiersSorting.ts
+function checkSpecifiersSorting2(categorized) {
+  const errors = [];
+  const namedReExports = categorized.filter(isNamedReExport);
+  for (const { declaration } of namedReExports) {
+    const specifiers = getNamedSpecifiers2(declaration);
+    const isSorted = areSpecifiersSorted2(specifiers);
+    if (specifiers.length > 1 && !isSorted) {
+      errors.push({
+        node: declaration,
+        messageId: "sortedNames"
+      });
+    }
+  }
+  return errors;
+}
+
+// src/rules/sortedReExports/sortSpecifiersText.ts
+function sortSpecifiersText2(specifiers, sourceCode) {
+  const sorted = [...specifiers].sort((a, b) => {
+    const nameA = getSpecifierName2(a);
+    const nameB = getSpecifierName2(b);
+    return compare(nameA, nameB);
+  });
+  return sorted.map((s) => sourceCode.getText(s)).join(", ");
+}
+
+// src/rules/sortedReExports/createFix/formatNamedReExport.ts
+function formatNamedReExport(declaration, sourceCode) {
+  const specifiers = getNamedSpecifiers2(declaration);
+  if (specifiers.length > 1 && !areSpecifiersSorted2(specifiers)) {
+    const sortedSpecifiers = sortSpecifiersText2(specifiers, sourceCode);
+    const source = declaration.source.value;
+    const prefix = declaration.exportKind === "type" ? "export type " : "export ";
+    return `${prefix}{${sortedSpecifiers}} from '${source}'`;
+  }
+  return sourceCode.getText(declaration);
+}
+
+// src/rules/sortedReExports/createFix/buildSortedCode.ts
+function buildSortedCode2(grouped, sourceCode) {
+  const sortedCode = [];
+  for (const group of reExportGroupOrder) {
+    for (const item of grouped[group]) {
+      if (isNamedReExport(item)) {
+        sortedCode.push(
+          formatNamedReExport(
+            item.declaration,
+            sourceCode
+          )
+        );
+      } else
+        sortedCode.push(sourceCode.getText(item.declaration));
+    }
+  }
+  return sortedCode;
+}
+
+// src/rules/sortedReExports/createFix/findFirstExportIndex.ts
+function findFirstExportIndex(programBody) {
+  for (let i = 0; i < programBody.length; i++) {
+    if (programBody[i].type === "ExportNamedDeclaration" || programBody[i].type === "ExportAllDeclaration") {
+      return i;
+    }
+  }
+  return -1;
+}
+
+// src/rules/sortedReExports/createFix/findLastExportIndex.ts
+function findLastExportIndex(programBody) {
+  let lastIndex = -1;
+  for (let i = 0; i < programBody.length; i++) {
+    if (programBody[i].type === "ExportNamedDeclaration" || programBody[i].type === "ExportAllDeclaration") {
+      lastIndex = i;
+    }
+  }
+  return lastIndex;
+}
+
+// src/rules/sortedReExports/createFix/getReplacementRange.ts
+function getReplacementRange2(programBody) {
+  const firstIndex = findFirstExportIndex(programBody);
+  const lastIndex = findLastExportIndex(programBody);
+  if (firstIndex === -1 || lastIndex === -1)
+    return { start: 0, end: 0 };
+  const firstExport = programBody[firstIndex];
+  const lastExport = programBody[lastIndex];
+  const start = firstExport.range[0];
+  const end = lastExport.range[1];
+  return { start, end };
+}
+
+// src/rules/sortedReExports/createFix/groupReExportsByType.ts
+function groupReExportsByType(categorized) {
+  const grouped = {
+    "re-export-all": [],
+    "re-export-named": [],
+    "re-export-type": []
+  };
+  for (const item of categorized)
+    grouped[item.group].push(item);
+  return grouped;
+}
+
+// src/rules/sortedReExports/createFix/sortExportGroups.ts
+function sortExportGroups(grouped) {
+  grouped["re-export-all"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  grouped["re-export-named"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  grouped["re-export-type"].sort((a, b) => compare(a.sortKey, b.sortKey));
+}
+
+// src/rules/sortedReExports/createFix/index.ts
+function createFix2(fixer, reExportDeclarations, sourceCode, programBody) {
+  const range = getReplacementRange2(programBody);
+  const categorized = categorizeReExports(reExportDeclarations);
+  const grouped = groupReExportsByType(categorized);
+  sortExportGroups(grouped);
+  const sortedCode = buildSortedCode2(grouped, sourceCode).join("\n");
+  return fixer.replaceTextRange(
+    [range.start, range.end],
+    sortedCode
+  );
+}
+
+// src/rules/sortedReExports/getReExportDeclarations.ts
+function getReExportDeclarations(programBody) {
+  return programBody.filter(
+    (statement) => statement.type === "ExportNamedDeclaration" && statement.source !== null || statement.type === "ExportAllDeclaration"
+  );
+}
+
+// src/rules/sortedReExports/index.ts
+var sortedReExports = {
+  meta: {
+    docs: {
+      description: "Enforce sorted exports alphabetically",
+      recommended: true
+    },
+    fixable: "code",
+    messages: {
+      sortedReExports: "Exports should be sorted alphabetically",
+      sortedNames: "Named exports should be sorted alphabetically",
+      wrongGroup: "Export is in wrong group"
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const body = node.body;
+        const declarations = getReExportDeclarations(body);
+        if (declarations.length === 0)
+          return;
+        const categorized = categorizeReExports(declarations);
+        const errors = [
+          ...checkGroupOrdering2(categorized),
+          ...checkAlphabeticalSorting2(categorized),
+          ...checkSpecifiersSorting2(categorized)
+        ];
+        for (const error of errors) {
+          context.report({
+            node: error.node,
+            messageId: error.messageId,
+            fix(fixer) {
+              const sourceCode = context.sourceCode;
+              return createFix2(fixer, declarations, sourceCode, body);
             }
           });
         }
@@ -335,14 +756,20 @@ var CONFIG = defineConfig([
     plugins: {
       "@borela-tech": {
         rules: {
+          "imports-and-re-exports-at-top": importsAndReExportsAtTop,
           "individual-imports": individualImports,
-          "sorted-imports": sortedImports
+          "individual-re-exports": individualReExports,
+          "sorted-imports": sortedImports,
+          "sorted-re-exports": sortedReExports
         }
       }
     },
     rules: {
+      "@borela-tech/imports-and-re-exports-at-top": "error",
       "@borela-tech/individual-imports": "error",
-      "@borela-tech/sorted-imports": "error"
+      "@borela-tech/individual-re-exports": "error",
+      "@borela-tech/sorted-imports": "error",
+      "@borela-tech/sorted-re-exports": "error"
     }
   },
   {