@borela-tech/eslint-config 2.1.2 → 2.2.1

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

package/src/rules/singleLineImports/formatSpecifiers.ts

@@ -0,0 +1,32 @@
+import {formatNamed} from './formatNamed'
+import type {TSESLint} from '@typescript-eslint/utils'
+import type {TSESTree} from '@typescript-eslint/utils'
+
+export function formatSpecifiers(
+  declaration: TSESTree.ImportDeclaration,
+  sourceCode: TSESLint.SourceCode,
+): string {
+  const defaultSpecifier = declaration.specifiers.find(
+    (s): s is TSESTree.ImportDefaultSpecifier => s.type === 'ImportDefaultSpecifier',
+  )
+  const namespaceSpecifier = declaration.specifiers.find(
+    (s): s is TSESTree.ImportNamespaceSpecifier => s.type === 'ImportNamespaceSpecifier',
+  )
+  const namedSpecifiers = declaration.specifiers.filter(
+    (s): s is TSESTree.ImportSpecifier => 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)}}`
+}

package/src/rules/singleLineImports/index.ts

@@ -0,0 +1,34 @@
+import {createFix} from './createFix'
+import {isMultiline} from './isMultiline'
+import type {TSESLint} from '@typescript-eslint/utils'
+
+type MessageIds = 'multiline'
+
+export const singleLineImports: TSESLint.RuleModule<MessageIds, []> = {
+  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 (!isMultiline(node))
+          return
+
+        context.report({
+          node,
+          messageId: 'multiline',
+          fix: fixer => createFix(fixer, node, context.sourceCode),
+        })
+      },
+    }
+  },
+}

package/src/rules/singleLineImports/isMultiline.ts

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

package/src/rules/singleLineReExports/createFix.ts

@@ -0,0 +1,29 @@
+import {formatAttributes} from '../singleLineImports/formatAttributes'
+import type {ReExportDeclaration} from '@lib/ReExportDeclaration'
+import type {TSESLint} from '@typescript-eslint/utils'
+
+export function createFix(
+  fixer: TSESLint.RuleFixer,
+  declaration: ReExportDeclaration,
+  sourceCode: TSESLint.SourceCode,
+): TSESLint.RuleFix {
+  const source = declaration.source!.value
+
+  if (declaration.type === 'ExportAllDeclaration') {
+    const exported = declaration.exported
+      ? `* as ${sourceCode.getText(declaration.exported)}`
+      : '*'
+    const attributes = formatAttributes(declaration.attributes)
+    const result = `export ${exported} from '${source}'${attributes}`
+    return fixer.replaceText(declaration, result)
+  }
+
+  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)
+}

package/src/rules/singleLineReExports/index.ts

@@ -0,0 +1,48 @@
+import {createFix} from './createFix'
+import {isMultiline} from './isMultiline'
+import type {ReExportDeclaration} from '@lib/ReExportDeclaration'
+import type {TSESLint} from '@typescript-eslint/utils'
+import type {TSESTree} from '@typescript-eslint/utils'
+
+type MessageIds = 'multiline'
+
+export const singleLineReExports: TSESLint.RuleModule<MessageIds, []> = {
+  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: TSESTree.Node,
+      declaration: ReExportDeclaration,
+    ) => {
+      // Skip local exports (only process re-exports with a source)
+      if (!declaration.source)
+        return
+
+      if (!isMultiline(declaration))
+        return
+
+      context.report({
+        node,
+        messageId: 'multiline',
+        fix: fixer => createFix(fixer, declaration, context.sourceCode),
+      })
+    }
+
+    return {
+      ExportNamedDeclaration: node =>
+        checkDeclaration(node, node),
+      ExportAllDeclaration: node =>
+        checkDeclaration(node, node),
+    }
+  },
+}

package/src/rules/singleLineReExports/isMultiline.ts

@@ -0,0 +1,6 @@
+import type {ReExportDeclaration} from '@lib/ReExportDeclaration'
+
+export function isMultiline(declaration: ReExportDeclaration) {
+  const {start, end} = declaration.loc ?? {}
+  return start?.line !== end?.line
+}

package/src/rules/sortedImports/ImportError.ts

@@ -2,5 +2,8 @@ import type {TSESTree} from '@typescript-eslint/types'
 
 export interface ImportError {
   node: TSESTree.ImportDeclaration
-  messageId: 'sortedImports' | 'sortedNames' | 'wrongGroup'
+  messageId:
+    | 'sortedImports'
+    | 'sortedNames'
+    | 'wrongGroup'
 }

package/src/rules/sortedImports/ImportGroup.ts

@@ -1,5 +1,6 @@
 export type ImportGroup =
-  | 'side-effect'
   | 'default'
   | 'named'
+  | 'namespace'
+  | 'side-effect'
   | 'type'

package/src/rules/sortedImports/ImportGroupOrder.ts

@@ -1,7 +1,8 @@
-import {ImportGroup} from './ImportGroup'
+import type {ImportGroup} from './ImportGroup'
 
 export const importGroupOrder: ImportGroup[] = [
   'side-effect',
+  'namespace',
   'default',
   'named',
   'type',

package/src/rules/sortedImports/areSpecifiersSorted.ts

@@ -1,4 +1,4 @@
-import {compare} from '../../lib/compare'
+import {compare} from '@lib/compare'
 import {getSpecifierName} from './getSpecifierName'
 import type {TSESTree} from '@typescript-eslint/types'
 

package/src/rules/sortedImports/categorizeImport.ts

@@ -10,6 +10,10 @@ export function categorizeImport(declaration: TSESTree.ImportDeclaration): Impor
   if (declaration.specifiers.length === 0)
     return 'side-effect'
 
+  // Example: import * as fs from 'module'
+  if (declaration.specifiers.some(s => s.type === 'ImportNamespaceSpecifier'))
+    return 'namespace'
+
   // Example: import value from 'module'
   if (declaration.specifiers.some(s => s.type === 'ImportDefaultSpecifier'))
     return 'default'

package/src/rules/sortedImports/checkAlphabeticalSorting.ts

@@ -1,4 +1,4 @@
-import {compare} from '../../lib/compare'
+import {compare} from '@lib/compare'
 import {importGroupOrder} from './ImportGroupOrder'
 import type {CategorizedImport} from './CategorizedImport'
 import type {ImportError} from './ImportError'