@borela-tech/eslint-config 2.1.1 → 2.2.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -4,7 +4,6 @@ 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";
 
 // src/rules/importsAndReExportsAtTop/getStatementType.ts
 function getStatementType(statement) {
@@ -19,6 +18,20 @@ function getStatementType(statement) {
   return "other";
 }
 
+// src/rules/importsAndReExportsAtTop/isImportDeclaration.ts
+function isImportDeclaration(statement) {
+  return statement.type === "ImportDeclaration";
+}
+
+// src/rules/importsAndReExportsAtTop/isReExport.ts
+function isReExport(statement) {
+  if (statement.type === "ExportAllDeclaration")
+    return true;
+  if (statement.type === "ExportNamedDeclaration")
+    return statement.source !== null;
+  return false;
+}
+
 // src/rules/importsAndReExportsAtTop/categorizeStatements.ts
 function categorizeStatements(statements) {
   const result = {
@@ -28,9 +41,9 @@ function categorizeStatements(statements) {
   };
   for (const statement of statements) {
     const type = getStatementType(statement);
-    if (type === "import")
+    if (type === "import" && isImportDeclaration(statement))
       result.imports.push(statement);
-    else if (type === "re-export")
+    else if (type === "re-export" && isReExport(statement))
       result.reExports.push(statement);
     else
       result.other.push(statement);
@@ -38,21 +51,21 @@ function categorizeStatements(statements) {
   return result;
 }
 
-// src/rules/importsAndReExportsAtTop/findFirstIndices.ts
-function findFirstIndices(statements) {
-  let firstImport = Infinity;
-  let firstReExport = Infinity;
-  let firstOther = -1;
+// src/rules/importsAndReExportsAtTop/findStatementIndices.ts
+function findStatementIndices(statements) {
+  let firstRegularStatement = -1;
+  let lastImport = -1;
+  let lastReExport = -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;
+    if (type === "import")
+      lastImport = i;
+    else if (type === "re-export")
+      lastReExport = i;
+    else if (type === "other" && firstRegularStatement === -1)
+      firstRegularStatement = i;
   }
-  return { firstImport, firstReExport, firstOther };
+  return { firstRegularStatement, lastImport, lastReExport };
 }
 
 // src/rules/importsAndReExportsAtTop/generateSortedText.ts
@@ -69,18 +82,12 @@ function generateSortedText(context, categories) {
 
 // src/rules/importsAndReExportsAtTop/hasViolation.ts
 function hasViolation(indices, categories) {
-  const {
-    firstImport,
-    firstReExport,
-    firstOther
-  } = indices;
-  if (categories.imports.length === 0 || categories.reExports.length === 0)
+  const { firstRegularStatement, lastImport, lastReExport } = 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;
+  const hasImportAfterRegularStatement = categories.imports.length > 0 && firstRegularStatement !== -1 && lastImport > firstRegularStatement;
+  const hasReExportAfterRegularStatement = categories.reExports.length > 0 && firstRegularStatement !== -1 && lastReExport > firstRegularStatement;
+  return hasImportAfterRegularStatement || hasReExportAfterRegularStatement;
 }
 
 // src/rules/importsAndReExportsAtTop/index.ts
@@ -88,8 +95,7 @@ var importsAndReExportsAtTop = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "Enforce imports and re-exports at the top of the file",
-      recommended: false
+      description: "Enforce imports and re-exports at the top of the file"
     },
     fixable: "code",
     messages: {
@@ -102,7 +108,7 @@ var importsAndReExportsAtTop = {
       Program(node) {
         const statements = node.body;
         const categories = categorizeStatements(statements);
-        const indices = findFirstIndices(statements);
+        const indices = findStatementIndices(statements);
         if (!hasViolation(indices, categories))
           return;
         context.report({
@@ -122,8 +128,7 @@ var importsAndReExportsAtTop = {
 var individualImports = {
   meta: {
     docs: {
-      description: "Enforce individual imports instead of grouped imports",
-      recommended: true
+      description: "Enforce individual imports instead of grouped imports"
     },
     fixable: "code",
     messages: {
@@ -155,8 +160,7 @@ var individualImports = {
 var individualReExports = {
   meta: {
     docs: {
-      description: "Enforce individual exports instead of grouped exports",
-      recommended: true
+      description: "Enforce individual exports instead of grouped exports"
     },
     fixable: "code",
     messages: {
@@ -168,16 +172,15 @@ var individualReExports = {
   create(context) {
     return {
       ExportNamedDeclaration(node) {
-        const exportNode = node;
-        if (!exportNode.source || exportNode.specifiers.length <= 1)
+        if (!node.source || node.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 source = node.source.value;
+            const typeKeyword = node.exportKind === "type" ? "type " : "";
+            const specifiers = node.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}`;
@@ -191,12 +194,215 @@ var individualReExports = {
   }
 };
 
+// src/rules/multilineUnionTypes/createFix.ts
+function createFix(fixer, node, sourceCode) {
+  const types = node.types.map((t) => sourceCode.getText(t));
+  const formattedTypes = types.map((t) => `  | ${t}`).join("\n");
+  const result = `
+${formattedTypes}`;
+  return fixer.replaceText(node, result);
+}
+
+// src/rules/multilineUnionTypes/isMultiline.ts
+function isMultiline(unionType) {
+  const { start, end } = unionType.loc ?? {};
+  return start?.line !== end?.line;
+}
+
+// src/rules/multilineUnionTypes/index.ts
+var multilineUnionTypes = {
+  meta: {
+    docs: {
+      description: "Enforce union types with multiple members to be on multiple lines"
+    },
+    fixable: "code",
+    messages: {
+      singleLine: "Union types with multiple members should be on multiple lines",
+      missingPipes: "Multiline union types should have leading pipes on each member"
+    },
+    schema: [],
+    type: "layout"
+  },
+  create(context) {
+    return {
+      TSUnionType(node) {
+        if (node.types.length < 2)
+          return;
+        const sourceCode = context.sourceCode;
+        const text = sourceCode.getText(node);
+        if (text.trim().startsWith("|"))
+          return;
+        if (!isMultiline(node)) {
+          context.report({
+            node,
+            messageId: "singleLine",
+            fix: (fixer) => createFix(fixer, node, sourceCode)
+          });
+          return;
+        }
+        context.report({
+          node,
+          messageId: "missingPipes",
+          fix: (fixer) => createFix(fixer, node, sourceCode)
+        });
+      }
+    };
+  }
+};
+
+// src/rules/singleLineImports/formatAttributes.ts
+function formatAttributes(attributes) {
+  if (attributes.length === 0)
+    return "";
+  const formatted = attributes.map(
+    (attr) => {
+      const key = attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
+      const value = attr.value.value;
+      return `${key}: '${value}'`;
+    }
+  ).join(", ");
+  return ` with {${formatted}}`;
+}
+
+// src/rules/singleLineImports/formatNamed.ts
+function formatNamed(specifiers, sourceCode) {
+  return specifiers.map((s) => sourceCode.getText(s)).join(", ");
+}
+
+// src/rules/singleLineImports/formatSpecifiers.ts
+function formatSpecifiers(declaration, sourceCode) {
+  const defaultSpecifier = declaration.specifiers.find(
+    (s) => s.type === "ImportDefaultSpecifier"
+  );
+  const namespaceSpecifier = declaration.specifiers.find(
+    (s) => s.type === "ImportNamespaceSpecifier"
+  );
+  const namedSpecifiers = declaration.specifiers.filter(
+    (s) => s.type === "ImportSpecifier"
+  );
+  if (namespaceSpecifier)
+    return `* as ${namespaceSpecifier.local.name}`;
+  if (defaultSpecifier && namedSpecifiers.length > 0)
+    return `${defaultSpecifier.local.name}, {${formatNamed(namedSpecifiers, sourceCode)}}`;
+  if (defaultSpecifier)
+    return defaultSpecifier.local.name;
+  if (namedSpecifiers.length === 0)
+    return "";
+  return `{${formatNamed(namedSpecifiers, sourceCode)}}`;
+}
+
+// src/rules/singleLineImports/createFix.ts
+function createFix2(fixer, declaration, sourceCode) {
+  const source = declaration.source.value;
+  const prefix = declaration.importKind === "type" ? "import type " : "import ";
+  const specifiers = formatSpecifiers(declaration, sourceCode);
+  const attributes = formatAttributes(declaration.attributes);
+  if (specifiers === "") {
+    const result2 = `${prefix}'${source}'${attributes}`;
+    return fixer.replaceText(declaration, result2);
+  }
+  const result = `${prefix}${specifiers} from '${source}'${attributes}`;
+  return fixer.replaceText(declaration, result);
+}
+
+// src/rules/singleLineImports/isMultiline.ts
+function isMultiline2(declaration) {
+  const { start, end } = declaration.loc ?? {};
+  return start?.line !== end?.line;
+}
+
+// src/rules/singleLineImports/index.ts
+var singleLineImports = {
+  meta: {
+    docs: {
+      description: "Enforce imports to be on a single line"
+    },
+    fixable: "code",
+    messages: {
+      multiline: "Import should be on a single line"
+    },
+    schema: [],
+    type: "layout"
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (!isMultiline2(node))
+          return;
+        context.report({
+          node,
+          messageId: "multiline",
+          fix: (fixer) => createFix2(fixer, node, context.sourceCode)
+        });
+      }
+    };
+  }
+};
+
+// src/rules/singleLineReExports/createFix.ts
+function createFix3(fixer, declaration, sourceCode) {
+  const source = declaration.source.value;
+  if (declaration.type === "ExportAllDeclaration") {
+    const exported = declaration.exported ? `* as ${sourceCode.getText(declaration.exported)}` : "*";
+    const attributes2 = formatAttributes(declaration.attributes);
+    const result2 = `export ${exported} from '${source}'${attributes2}`;
+    return fixer.replaceText(declaration, result2);
+  }
+  const prefix = declaration.exportKind === "type" ? "export type " : "export ";
+  const specifiers = declaration.specifiers.map(
+    (s) => sourceCode.getText(s)
+  ).join(", ");
+  const attributes = formatAttributes(declaration.attributes);
+  const result = `${prefix}{${specifiers}} from '${source}'${attributes}`;
+  return fixer.replaceText(declaration, result);
+}
+
+// src/rules/singleLineReExports/isMultiline.ts
+function isMultiline3(declaration) {
+  const { start, end } = declaration.loc ?? {};
+  return start?.line !== end?.line;
+}
+
+// src/rules/singleLineReExports/index.ts
+var singleLineReExports = {
+  meta: {
+    docs: {
+      description: "Enforce re-exports to be on a single line"
+    },
+    fixable: "code",
+    messages: {
+      multiline: "Re-export should be on a single line"
+    },
+    schema: [],
+    type: "layout"
+  },
+  create(context) {
+    const checkDeclaration = (node, declaration) => {
+      if (!declaration.source)
+        return;
+      if (!isMultiline3(declaration))
+        return;
+      context.report({
+        node,
+        messageId: "multiline",
+        fix: (fixer) => createFix3(fixer, declaration, context.sourceCode)
+      });
+    };
+    return {
+      ExportNamedDeclaration: (node) => checkDeclaration(node, node),
+      ExportAllDeclaration: (node) => checkDeclaration(node, node)
+    };
+  }
+};
+
 // 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 === "ImportNamespaceSpecifier"))
+    return "namespace";
   if (declaration.specifiers.some((s) => s.type === "ImportDefaultSpecifier"))
     return "default";
   return "named";
@@ -207,6 +413,12 @@ function getSortKey(declaration) {
   const group = categorizeImport(declaration);
   if (group === "side-effect")
     return declaration.source.value;
+  if (group === "namespace") {
+    const namespaceSpecifier = declaration.specifiers.find(
+      (s) => s.type === "ImportNamespaceSpecifier"
+    );
+    return `*${namespaceSpecifier?.local.name ?? ""}`;
+  }
   if (group === "default") {
     const defaultSpecifier = declaration.specifiers.find(
       (s) => s.type === "ImportDefaultSpecifier"
@@ -234,6 +446,7 @@ function compare(a, b) {
 // src/rules/sortedImports/ImportGroupOrder.ts
 var importGroupOrder = [
   "side-effect",
+  "namespace",
   "default",
   "named",
   "type"
@@ -349,6 +562,7 @@ function buildSortedCode(grouped, sourceCode) {
 function groupImportsByType(categorized) {
   const grouped = {
     "side-effect": [],
+    namespace: [],
     default: [],
     named: [],
     type: []
@@ -361,6 +575,7 @@ function groupImportsByType(categorized) {
 // src/rules/sortedImports/createFix/sortImportGroups.ts
 function sortImportGroups(grouped) {
   grouped["side-effect"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  grouped["namespace"].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));
@@ -368,9 +583,8 @@ function sortImportGroups(grouped) {
 
 // src/rules/sortedImports/createFix/index.ts
 function createFixForGroup(fixer, importDeclarations, sourceCode) {
-  if (importDeclarations.length === 0) {
+  if (importDeclarations.length === 0)
     return null;
-  }
   const categorized = categorizeImports(importDeclarations);
   const grouped = groupImportsByType(categorized);
   sortImportGroups(grouped);
@@ -382,7 +596,7 @@ function createFixForGroup(fixer, importDeclarations, sourceCode) {
     sortedCode
   );
 }
-function createFix(fixer, importGroups, sourceCode) {
+function createFix4(fixer, importGroups, sourceCode) {
   const fixes = [];
   for (const group of importGroups) {
     const fix = createFixForGroup(fixer, group, sourceCode);
@@ -415,8 +629,7 @@ function getImportGroups(programBody) {
 var sortedImports = {
   meta: {
     docs: {
-      description: "Enforce sorted imports alphabetically",
-      recommended: true
+      description: "Enforce sorted imports alphabetically"
     },
     fixable: "code",
     messages: {
@@ -450,7 +663,7 @@ var sortedImports = {
             messageId: error.messageId,
             fix(fixer) {
               const sourceCode = context.sourceCode;
-              return createFix(fixer, importGroups, sourceCode);
+              return createFix4(fixer, importGroups, sourceCode);
             }
           });
         }
@@ -461,8 +674,11 @@ var sortedImports = {
 
 // src/rules/sortedReExports/categorizeReExport.ts
 function categorizeReExport(declaration) {
-  if (declaration.type === "ExportAllDeclaration")
+  if (declaration.type === "ExportAllDeclaration") {
+    if (declaration.exported)
+      return "re-export-namespace";
     return "re-export-all";
+  }
   if (declaration.exportKind === "type")
     return "re-export-type";
   return "re-export-named";
@@ -470,8 +686,14 @@ function categorizeReExport(declaration) {
 
 // src/rules/sortedReExports/getSortKey.ts
 function getSortKey2(declaration) {
-  if (declaration.type === "ExportAllDeclaration")
+  const group = categorizeReExport(declaration);
+  if (declaration.type === "ExportAllDeclaration") {
+    if (group === "re-export-namespace") {
+      if (declaration.exported?.type === "Identifier")
+        return `*${declaration.exported.name}`;
+    }
     return declaration.source.value;
+  }
   const specifier = declaration.specifiers[0];
   if (!specifier)
     return "";
@@ -492,6 +714,7 @@ function categorizeReExports(declarations) {
 // src/rules/sortedReExports/ReExportGroupOrder.ts
 var reExportGroupOrder = [
   "re-export-all",
+  "re-export-namespace",
   "re-export-named",
   "re-export-type"
 ];
@@ -554,7 +777,7 @@ function getNamedSpecifiers2(declaration) {
 
 // src/rules/sortedReExports/isNamedReExport.ts
 function isNamedReExport(x) {
-  return x.group !== "re-export-all";
+  return x.group !== "re-export-all" && x.group !== "re-export-namespace";
 }
 
 // src/rules/sortedReExports/checkSpecifiersSorting.ts
@@ -619,6 +842,7 @@ function buildSortedCode2(grouped, sourceCode) {
 function groupReExportsByType(categorized) {
   const grouped = {
     "re-export-all": [],
+    "re-export-namespace": [],
     "re-export-named": [],
     "re-export-type": []
   };
@@ -630,15 +854,15 @@ function groupReExportsByType(categorized) {
 // src/rules/sortedReExports/createFix/sortExportGroups.ts
 function sortExportGroups(grouped) {
   grouped["re-export-all"].sort((a, b) => compare(a.sortKey, b.sortKey));
+  grouped["re-export-namespace"].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 createFixForGroup2(fixer, reExportDeclarations, sourceCode) {
-  if (reExportDeclarations.length === 0) {
+  if (reExportDeclarations.length === 0)
     return null;
-  }
   const categorized = categorizeReExports(reExportDeclarations);
   const grouped = groupReExportsByType(categorized);
   sortExportGroups(grouped);
@@ -650,7 +874,7 @@ function createFixForGroup2(fixer, reExportDeclarations, sourceCode) {
     sortedCode
   );
 }
-function createFix2(fixer, reExportGroups, sourceCode) {
+function createFix5(fixer, reExportGroups, sourceCode) {
   const fixes = [];
   for (const group of reExportGroups) {
     const fix = createFixForGroup2(fixer, group, sourceCode);
@@ -686,8 +910,7 @@ function getReExportGroups(programBody) {
 var sortedReExports = {
   meta: {
     docs: {
-      description: "Enforce sorted exports alphabetically",
-      recommended: true
+      description: "Enforce sorted exports alphabetically"
     },
     fixable: "code",
     messages: {
@@ -721,7 +944,7 @@ var sortedReExports = {
             messageId: error.messageId,
             fix(fixer) {
               const sourceCode = context.sourceCode;
-              return createFix2(fixer, reExportGroups, sourceCode);
+              return createFix5(fixer, reExportGroups, sourceCode);
             }
           });
         }
@@ -731,7 +954,7 @@ var sortedReExports = {
 };
 
 // src/index.ts
-var CONFIG = defineConfig([
+var CONFIG = [
   {
     ignores: [
       "src/graphql/sdk.ts",
@@ -749,8 +972,8 @@ var CONFIG = defineConfig([
   eslint.configs.recommended,
   react.configs.flat.recommended,
   stylistic.configs.recommended,
-  typescript.configs.recommended,
-  typescript.configs.stylistic,
+  ...typescript.configs.recommended,
+  ...typescript.configs.stylistic,
   {
     plugins: {
       "react-hooks": reactHooks
@@ -764,6 +987,9 @@ var CONFIG = defineConfig([
           "imports-and-re-exports-at-top": importsAndReExportsAtTop,
           "individual-imports": individualImports,
           "individual-re-exports": individualReExports,
+          "multiline-union-types": multilineUnionTypes,
+          "single-line-imports": singleLineImports,
+          "single-line-re-exports": singleLineReExports,
           "sorted-imports": sortedImports,
           "sorted-re-exports": sortedReExports
         }
@@ -773,6 +999,9 @@ var CONFIG = defineConfig([
       "@borela-tech/imports-and-re-exports-at-top": "error",
       "@borela-tech/individual-imports": "error",
       "@borela-tech/individual-re-exports": "error",
+      "@borela-tech/multiline-union-types": "error",
+      "@borela-tech/single-line-imports": "error",
+      "@borela-tech/single-line-re-exports": "error",
       "@borela-tech/sorted-imports": "error",
       "@borela-tech/sorted-re-exports": "error"
     }
@@ -851,10 +1080,14 @@ var CONFIG = defineConfig([
         { beforeStatementContinuationChars: "always" }
       ],
       "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/consistent-indexed-object-style": "off"
+      "@typescript-eslint/consistent-indexed-object-style": "off",
+      "@typescript-eslint/consistent-type-imports": [
+        "error",
+        { fixStyle: "separate-type-imports" }
+      ]
     }
   }
-]);
+];
 export {
   CONFIG
 };