@borela-tech/eslint-config 2.1.1 → 2.2.0

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

@@ -0,0 +1,129 @@
+import typescript from 'typescript-eslint'
+import {dedent} from './dedent'
+import {RuleTester} from 'eslint'
+import {singleLineImports} from '../singleLineImports'
+import type {Rule} from 'eslint'
+
+const rule = singleLineImports as unknown as Rule.RuleModule
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: typescript.parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+})
+
+ruleTester.run('single-line-imports', rule, {
+  valid: [{
+    code: "import {foo} from 'bar'",
+  }, {
+    code: "import foo from 'bar'",
+  }, {
+    code: "import * as foo from 'bar'",
+  }, {
+    code: "import 'bar'",
+  }, {
+    code: "import type {Foo} from 'bar'",
+  }, {
+    code: "import foo, {bar} from 'baz'",
+  }, {
+    code: "import {a, b, c} from 'bar'",
+  }, {
+    code: "import {foo} from 'bar' with {type: 'json'}",
+  }, {
+    code: "import type {Foo} from 'bar' with {type: 'json'}",
+  }],
+  invalid: [{
+    code: dedent`
+      import {
+        foo,
+      } from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import {foo} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import type {
+        Foo,
+      } from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import type {Foo} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {
+        a,
+        b,
+        c,
+      } from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import {a, b, c} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import foo, {
+        bar,
+      } from 'baz'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import foo, {bar} from 'baz'
+    `,
+  }, {
+    code: dedent`
+      import
+        foo
+        from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import foo from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import * as foo
+        from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import * as foo from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import
+        'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {
+        foo,
+      } from 'bar' with {type: 'json'}
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import {foo} from 'bar' with {type: 'json'}
+    `,
+  }, {
+    code: dedent`
+      import type {
+        Foo,
+      } from 'bar' with {type: 'json'}
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      import type {Foo} from 'bar' with {type: 'json'}
+    `,
+  }],
+})

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

@@ -0,0 +1,100 @@
+import typescript from 'typescript-eslint'
+import {dedent} from './dedent'
+import {RuleTester} from 'eslint'
+import {singleLineReExports} from '../singleLineReExports'
+import type {Rule} from 'eslint'
+
+const rule = singleLineReExports as unknown as Rule.RuleModule
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: typescript.parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+})
+
+ruleTester.run('single-line-re-exports', rule, {
+  valid: [{
+    code: "export {foo} from 'bar'",
+  }, {
+    code: "export * from 'bar'",
+  }, {
+    code: "export * as foo from 'bar'",
+  }, {
+    code: "export type {Foo} from 'bar'",
+  }, {
+    code: "export {a, b, c} from 'bar'",
+  }, {
+    // Local export, not a re-export
+    code: dedent`
+      export {
+        foo,
+      }
+    `,
+  }, {
+    code: "export {foo} from 'bar' with {type: 'json'}",
+  }],
+  invalid: [{
+    code: dedent`
+      export {
+        foo,
+      } from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      export {foo} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      export type {
+        Foo,
+      } from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      export type {Foo} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      export {
+        a,
+        b,
+        c,
+      } from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      export {a, b, c} from 'bar'
+    `,
+  }, {
+    code: `
+      export {
+        foo,
+      } from 'bar' with {type: 'json'}
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: `
+      export {foo} from 'bar' with {type: 'json'}
+    `,
+  }, {
+    code: dedent`
+      export *
+      from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      export * from 'bar'
+    `,
+  }, {
+    code: dedent`
+      export * as foo
+      from 'bar'
+    `,
+    errors: [{messageId: 'multiline'}],
+    output: dedent`
+      export * as foo from 'bar'
+    `,
+  }],
+})

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

@@ -2,7 +2,9 @@ import typescript from 'typescript-eslint'
 import {dedent} from './dedent'
 import {RuleTester} from 'eslint'
 import {sortedImports} from '../sortedImports'
+import type {Rule} from 'eslint'
 
+const rule = sortedImports as unknown as Rule.RuleModule
 const ruleTester = new RuleTester({
   languageOptions: {
     parser: typescript.parser,
@@ -13,7 +15,7 @@ const ruleTester = new RuleTester({
   },
 })
 
-ruleTester.run('sorted-imports', sortedImports, {
+ruleTester.run('sorted-imports', rule, {
   valid: [{
     code: "import {foo} from 'bar'",
   }, {
@@ -22,10 +24,14 @@ ruleTester.run('sorted-imports', sortedImports, {
     code: "import 'bar'",
   }, {
     code: "import type {Foo} from 'bar'",
+  }, {
+    code: "import * as fs from 'fs'",
   }, {
     code: dedent`
       import 'aaa'
       import 'bbb'
+      import * as fs from 'fs'
+      import * as path from 'path'
       import bar from 'bbb'
       import foo from 'aaa'
       import {a} from 'aaa'
@@ -187,5 +193,35 @@ ruleTester.run('sorted-imports', sortedImports, {
       import {basename} from 'path'
       import {existsSync} from 'fs'
     `,
+  }, {
+    code: dedent`
+      import * as path from 'path'
+      import * as fs from 'fs'
+    `,
+    errors: [{messageId: 'sortedImports'}, {messageId: 'sortedImports'}],
+    output: dedent`
+      import * as fs from 'fs'
+      import * as path from 'path'
+    `,
+  }, {
+    code: dedent`
+      import {foo} from 'bar'
+      import * as fs from 'fs'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      import * as fs from 'fs'
+      import {foo} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import foo from 'bar'
+      import * as fs from 'fs'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      import * as fs from 'fs'
+      import foo from 'bar'
+    `,
   }],
 })

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

@@ -2,7 +2,9 @@ import typescript from 'typescript-eslint'
 import {dedent} from './dedent'
 import {RuleTester} from 'eslint'
 import {sortedReExports} from '../sortedReExports'
+import type {Rule} from 'eslint'
 
+const rule = sortedReExports as unknown as Rule.RuleModule
 const ruleTester = new RuleTester({
   languageOptions: {
     parser: typescript.parser,
@@ -13,7 +15,7 @@ const ruleTester = new RuleTester({
   },
 })
 
-ruleTester.run('sorted-re-exports', sortedReExports, {
+ruleTester.run('sorted-re-exports', rule, {
   valid: [{
     code: 'export const foo = 42',
   }, {
@@ -26,9 +28,13 @@ ruleTester.run('sorted-re-exports', sortedReExports, {
     code: "export * from 'bar'",
   }, {
     code: "export type {Foo} from 'bar'",
+  }, {
+    code: "export * as ns from 'bar'",
   }, {
     code: dedent`
       export * from 'aaa'
+      export * as fs from 'fs'
+      export * as path from 'path'
       export {a} from 'aaa'
       export {b} from 'bbb'
       export type {X} from 'xxx'
@@ -190,5 +196,25 @@ ruleTester.run('sorted-re-exports', sortedReExports, {
       export {basename} from 'path'
       export {existsSync} from 'fs'
     `,
+  }, {
+    code: dedent`
+      export * as path from 'path'
+      export * as fs from 'fs'
+    `,
+    errors: [{messageId: 'sortedReExports'}, {messageId: 'sortedReExports'}],
+    output: dedent`
+      export * as fs from 'fs'
+      export * as path from 'path'
+    `,
+  }, {
+    code: dedent`
+      export {foo} from 'bar'
+      export * as fs from 'fs'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      export * as fs from 'fs'
+      export {foo} from 'bar'
+    `,
   }],
 })

package/src/rules/importsAndReExportsAtTop/CategorizedStatements.ts

@@ -1,8 +1,8 @@
-import type {ReExport} from './ReExport'
+import type {ReExportDeclaration} from '@lib/ReExportDeclaration'
 import type {TSESTree} from '@typescript-eslint/types'
 
 export interface CategorizedStatements {
   imports: TSESTree.ImportDeclaration[]
-  reExports: ReExport[]
+  reExports: ReExportDeclaration[]
   other: TSESTree.Statement[]
 }

package/src/rules/importsAndReExportsAtTop/StatementIndices.ts

@@ -1,5 +1,5 @@
 export interface StatementIndices {
-  firstImport: number
-  firstReExport: number
-  firstOther: number
+  firstRegularStatement: number
+  lastImport: number
+  lastReExport: number
 }

package/src/rules/importsAndReExportsAtTop/categorizeStatements.ts

@@ -1,10 +1,11 @@
 import {getStatementType} from './getStatementType'
-import {ReExport} from './ReExport'
+import {isImportDeclaration} from './isImportDeclaration'
+import {isReExport} from './isReExport'
 import type {CategorizedStatements} from './CategorizedStatements'
 import type {TSESTree} from '@typescript-eslint/types'
 
 export function categorizeStatements(
-  statements: TSESTree.Statement[],
+  statements: TSESTree.ProgramStatement[],
 ): CategorizedStatements {
   const result: CategorizedStatements = {
     imports: [],
@@ -15,10 +16,10 @@ export function categorizeStatements(
   for (const statement of statements) {
     const type = getStatementType(statement)
 
-    if (type === 'import')
-      result.imports.push(statement as TSESTree.ImportDeclaration)
-    else if (type === 're-export')
-      result.reExports.push(statement as ReExport)
+    if (type === 'import' && isImportDeclaration(statement))
+      result.imports.push(statement)
+    else if (type === 're-export' && isReExport(statement))
+      result.reExports.push(statement)
     else
       result.other.push(statement)
   }

package/src/rules/importsAndReExportsAtTop/findStatementIndices.ts

@@ -0,0 +1,25 @@
+import {getStatementType} from './getStatementType'
+import type {StatementIndices} from './StatementIndices'
+import type {StatementType} from './statementType'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function findStatementIndices(
+  statements: TSESTree.Statement[],
+): StatementIndices {
+  let firstRegularStatement = -1
+  let lastImport = -1
+  let lastReExport = -1
+
+  for (let i = 0; i < statements.length; i++) {
+    const type: StatementType = getStatementType(statements[i])
+
+    if (type === 'import')
+      lastImport = i
+    else if (type === 're-export')
+      lastReExport = i
+    else if (type === 'other' && firstRegularStatement === -1)
+      firstRegularStatement = i
+  }
+
+  return {firstRegularStatement, lastImport, lastReExport}
+}

package/src/rules/importsAndReExportsAtTop/generateSortedText.ts

@@ -1,18 +1,16 @@
-import {Rule} from 'eslint'
 import type {CategorizedStatements} from './CategorizedStatements'
-import type {Node as ESTreeNode} from 'estree'
-import type {TSESTree} from '@typescript-eslint/types'
+import type {TSESLint} from '@typescript-eslint/utils'
 
 export function generateSortedText(
-  context: Rule.RuleContext,
+  context: TSESLint.RuleContext<'importsAndReExportsAtTop', []>,
   categories: CategorizedStatements,
 ): string {
-  const allStatements: TSESTree.Node[] = [
+  const allStatements = [
     ...categories.imports,
     ...categories.reExports,
     ...categories.other,
   ]
   return allStatements.map(
-    node => context.sourceCode.getText(node as ESTreeNode),
+    node => context.sourceCode.getText(node),
   ).join('\n')
 }

package/src/rules/importsAndReExportsAtTop/getStatementType.ts

@@ -1,4 +1,4 @@
-import {StatementType} from './statementType'
+import type {StatementType} from './statementType'
 import type {TSESTree} from '@typescript-eslint/types'
 
 export function getStatementType(statement: TSESTree.Statement): StatementType {

package/src/rules/importsAndReExportsAtTop/hasViolation.ts

@@ -5,25 +5,21 @@ export function hasViolation(
   indices: StatementIndices,
   categories: CategorizedStatements,
 ): boolean {
-  const {
-    firstImport,
-    firstReExport,
-    firstOther,
-  } = indices
+  const {firstRegularStatement, lastImport, lastReExport} = indices
 
-  // No imports or no re-exports.
-  if (categories.imports.length === 0 || categories.reExports.length === 0)
+  if (categories.imports.length === 0 && categories.reExports.length === 0)
     return false
 
-  const firstImportOrReExport = Math.min(firstImport, firstReExport)
-  const hasOtherBeforeImportOrReExport =
-    firstOther !== -1 && firstOther < firstImportOrReExport
+  const hasImportAfterRegularStatement = (
+    categories.imports.length > 0
+    && firstRegularStatement !== -1
+    && lastImport > firstRegularStatement
+  )
+  const hasReExportAfterRegularStatement = (
+    categories.reExports.length > 0
+    && firstRegularStatement !== -1
+    && lastReExport > firstRegularStatement
+  )
 
-  // Violation if:
-  // 1. Other statements appear before imports/re-exports.
-  // 2. Re-exports appear before imports.
-  if (hasOtherBeforeImportOrReExport || firstImport > firstReExport)
-    return true
-
-  return false
+  return hasImportAfterRegularStatement || hasReExportAfterRegularStatement
 }

package/src/rules/importsAndReExportsAtTop/index.ts

@@ -1,16 +1,16 @@
 import {categorizeStatements} from './categorizeStatements'
-import {findFirstIndices} from './findFirstIndices'
+import {findStatementIndices} from './findStatementIndices'
 import {generateSortedText} from './generateSortedText'
 import {hasViolation} from './hasViolation'
-import type {Rule} from 'eslint'
-import type {TSESTree} from '@typescript-eslint/types'
+import type {TSESLint} from '@typescript-eslint/utils'
 
-export const importsAndReExportsAtTop: Rule.RuleModule = {
+type MessageIds = 'importsAndReExportsAtTop'
+
+export const importsAndReExportsAtTop: TSESLint.RuleModule<MessageIds, []> = {
   meta: {
     type: 'suggestion',
     docs: {
       description: 'Enforce imports and re-exports at the top of the file',
-      recommended: false,
     },
     fixable: 'code',
     messages: {
@@ -23,9 +23,9 @@ export const importsAndReExportsAtTop: Rule.RuleModule = {
   create(context) {
     return {
       Program(node) {
-        const statements = node.body as TSESTree.Statement[]
+        const statements = node.body
         const categories = categorizeStatements(statements)
-        const indices = findFirstIndices(statements)
+        const indices = findStatementIndices(statements)
 
         if (!hasViolation(indices, categories))
           return

package/src/rules/importsAndReExportsAtTop/isImportDeclaration.ts

@@ -0,0 +1,7 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function isImportDeclaration(
+  statement: TSESTree.ProgramStatement,
+): statement is TSESTree.ImportDeclaration {
+  return statement.type === 'ImportDeclaration'
+}

package/src/rules/importsAndReExportsAtTop/isReExport.ts

@@ -0,0 +1,12 @@
+import type {ReExportDeclaration} from '@lib/ReExportDeclaration'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function isReExport(
+  statement: TSESTree.ProgramStatement,
+): statement is ReExportDeclaration {
+  if (statement.type === 'ExportAllDeclaration')
+    return true
+  if (statement.type === 'ExportNamedDeclaration')
+    return statement.source !== null
+  return false
+}

package/src/rules/individualImports.ts

@@ -1,10 +1,11 @@
-import type {Rule} from 'eslint'
+import type {TSESLint} from '@typescript-eslint/utils'
 
-export const individualImports: Rule.RuleModule = {
+type MessageIds = 'individualImports'
+
+export const individualImports: TSESLint.RuleModule<MessageIds, []> = {
   meta: {
     docs: {
       description: 'Enforce individual imports instead of grouped imports',
-      recommended: true,
     },
     fixable: 'code',
     messages: {

package/src/rules/individualReExports.ts

@@ -1,11 +1,11 @@
-import type {Rule} from 'eslint'
-import type {TSESTree} from '@typescript-eslint/types'
+import type {TSESLint} from '@typescript-eslint/utils'
 
-export const individualReExports: Rule.RuleModule = {
+type MessageIds = 'individualReExports'
+
+export const individualReExports: TSESLint.RuleModule<MessageIds, []> = {
   meta: {
     docs: {
       description: 'Enforce individual exports instead of grouped exports',
-      recommended: true,
     },
     fixable: 'code',
     messages: {
@@ -17,19 +17,18 @@ export const individualReExports: Rule.RuleModule = {
   create(context) {
     return {
       ExportNamedDeclaration(node) {
-        const exportNode = node as TSESTree.ExportNamedDeclaration
-        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'
+            const source = node.source.value
+            const typeKeyword = node.exportKind === 'type'
               ? 'type '
               : ''
-            const specifiers = exportNode.specifiers
+            const specifiers = node.specifiers
               .map(s => {
                 const localName = s.local.type === 'Identifier'
                   ? s.local.name

package/src/rules/multilineUnionTypes/createFix.ts

@@ -0,0 +1,13 @@
+import type {TSESLint} from '@typescript-eslint/utils'
+import type {TSESTree} from '@typescript-eslint/utils'
+
+export function createFix(
+  fixer: TSESLint.RuleFixer,
+  node: TSESTree.TSUnionType,
+  sourceCode: TSESLint.SourceCode,
+): TSESLint.RuleFix {
+  const types = node.types.map(t => sourceCode.getText(t))
+  const formattedTypes = types.map(t => `  | ${t}`).join('\n')
+  const result = `\n${formattedTypes}`
+  return fixer.replaceText(node, result)
+}

package/src/rules/multilineUnionTypes/index.ts

@@ -0,0 +1,52 @@
+import {createFix} from './createFix'
+import {isMultiline} from './isMultiline'
+import type {TSESLint} from '@typescript-eslint/utils'
+
+type MessageIds =
+  | 'singleLine'
+  | 'missingPipes'
+
+export const multilineUnionTypes: TSESLint.RuleModule<MessageIds, []> = {
+  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),
+        })
+      },
+    }
+  },
+}