@borela-tech/eslint-config 2.1.2 → 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/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/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/index.ts

@@ -2,15 +2,15 @@ import {categorizeStatements} from './categorizeStatements'
 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,7 +23,7 @@ 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 = findStatementIndices(statements)
 

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),
+        })
+      },
+    }
+  },
+}

package/src/rules/multilineUnionTypes/isMultiline.ts

@@ -0,0 +1,6 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function isMultiline(unionType: TSESTree.TSUnionType) {
+  const {start, end} = unionType.loc ?? {}
+  return start?.line !== end?.line
+}

package/src/rules/singleLineImports/createFix.ts

@@ -0,0 +1,23 @@
+import {formatAttributes} from './formatAttributes'
+import {formatSpecifiers} from './formatSpecifiers'
+import type {TSESLint} from '@typescript-eslint/utils'
+import type {TSESTree} from '@typescript-eslint/utils'
+
+export function createFix(
+  fixer: TSESLint.RuleFixer,
+  declaration: TSESTree.ImportDeclaration,
+  sourceCode: TSESLint.SourceCode,
+): TSESLint.RuleFix {
+  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 result = `${prefix}'${source}'${attributes}`
+    return fixer.replaceText(declaration, result)
+  }
+
+  const result = `${prefix}${specifiers} from '${source}'${attributes}`
+  return fixer.replaceText(declaration, result)
+}

package/src/rules/singleLineImports/formatAttributes.ts

@@ -0,0 +1,20 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function formatAttributes(
+  attributes: readonly TSESTree.ImportAttribute[],
+): string {
+  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}}`
+}

package/src/rules/singleLineImports/formatNamed.ts

@@ -0,0 +1,9 @@
+import type {TSESLint} from '@typescript-eslint/utils'
+import type {TSESTree} from '@typescript-eslint/utils'
+
+export function formatNamed(
+  specifiers: TSESTree.ImportSpecifier[],
+  sourceCode: TSESLint.SourceCode,
+): string {
+  return specifiers.map(s => sourceCode.getText(s)).join(', ')
+}