@borela-tech/eslint-config 1.3.3 → 2.0.1

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

@@ -0,0 +1,42 @@
+import typescript from 'typescript-eslint'
+import {dedent} from './dedent'
+import {individualImports} from '../individualImports'
+import {RuleTester} from 'eslint'
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: typescript.parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+})
+
+ruleTester.run('individual-imports', individualImports, {
+  valid: [{
+    code: "import {foo} from 'bar'",
+  }, {
+    code: "import foo from 'bar'",
+  }, {
+    code: "import * as foo from 'bar'",
+  }, {
+    code: "import 'bar'",
+  }],
+  invalid: [{
+    code: "import {foo, bar} from 'baz'",
+    errors: [{messageId: 'individualImports'}],
+    output: dedent`
+      import {foo} from 'baz'
+      import {bar} from 'baz'
+    `,
+  }, {
+    code: "import {foo, bar, baz} from 'qux'",
+    errors: [{messageId: 'individualImports'}],
+    output: dedent`
+      import {foo} from 'qux'
+      import {bar} from 'qux'
+      import {baz} from 'qux'
+    `,
+  }],
+})

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

@@ -0,0 +1,148 @@
+import typescript from 'typescript-eslint'
+import {dedent} from './dedent'
+import {RuleTester} from 'eslint'
+import {sortedImports} from '../sortedImports'
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: typescript.parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+})
+
+ruleTester.run('sorted-imports', sortedImports, {
+  valid: [{
+    code: "import {foo} from 'bar'",
+  }, {
+    code: "import foo from 'bar'",
+  }, {
+    code: "import 'bar'",
+  }, {
+    code: "import type {Foo} from 'bar'",
+  }, {
+    code: dedent`
+      import 'aaa'
+      import 'bbb'
+      import bar from 'bbb'
+      import foo from 'aaa'
+      import {a} from 'aaa'
+      import {b} from 'bbb'
+      import type {X} from 'xxx'
+      import type {Y} from 'yyy'
+    `,
+  }, {
+    code: dedent`
+      import {a} from 'ccc'
+      import {b} from 'aaa'
+      import {c} from 'bbb'
+    `,
+  }, {
+    code: dedent`
+      import {a, b, c} from 'bar'
+    `,
+  }, {
+    code: '',
+  }, {
+    code: 'const x = 1',
+  }],
+  invalid: [{
+    code: dedent`
+      import {c, a, b} from 'bar'
+    `,
+    errors: [{messageId: 'sortedNames'}],
+    output: dedent`
+      import { a, b, c } from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {z, a} from 'bar'
+    `,
+    errors: [{messageId: 'sortedNames'}],
+    output: dedent`
+      import { a, z } from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import foo from 'aaa'
+      import bar from 'bbb'
+    `,
+    errors: [{messageId: 'sortedImports'}, {messageId: 'sortedImports'}],
+    output: dedent`
+      import bar from 'bbb'
+      import foo from 'aaa'
+    `,
+  }, {
+    code: dedent`
+      import 'bbb'
+      import 'aaa'
+    `,
+    errors: [{messageId: 'sortedImports'}, {messageId: 'sortedImports'}],
+    output: dedent`
+      import 'aaa'
+      import 'bbb'
+    `,
+  }, {
+    code: dedent`
+      import foo from 'bar'
+      import 'baz'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      import 'baz'
+      import foo from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {a} from 'bar'
+      import foo from 'baz'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      import foo from 'baz'
+      import {a} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {b, a} from 'bar'
+      import foo from 'baz'
+    `,
+    errors: [{messageId: 'sortedNames'}, {messageId: 'wrongGroup'}],
+    output: dedent`
+      import foo from 'baz'
+      import { a, b } from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import type {Y} from 'yyy'
+      import type {X} from 'xxx'
+    `,
+    errors: [{messageId: 'sortedImports'}, {messageId: 'sortedImports'}],
+    output: dedent`
+      import type {X} from 'xxx'
+      import type {Y} from 'yyy'
+    `,
+  }, {
+    code: dedent`
+      import type {Foo} from 'bar'
+      import {baz} from 'qux'
+    `,
+    errors: [{messageId: 'wrongGroup'}],
+    output: dedent`
+      import {baz} from 'qux'
+      import type {Foo} from 'bar'
+    `,
+  }, {
+    code: dedent`
+      import {existsSync} from 'fs'
+      import {basename} from 'path'
+    `,
+    errors: [{messageId: 'sortedImports'}, {messageId: 'sortedImports'}],
+    output: dedent`
+      import {basename} from 'path'
+      import {existsSync} from 'fs'
+    `,
+  }],
+})

package/src/rules/individualImports.ts

@@ -24,9 +24,9 @@ export const individualImports: Rule.RuleModule = {
           fix(fixer) {
             const source = node.source.raw
             const specifiers = node.specifiers
-              .map(specifier => {
-                if (specifier.type === 'ImportSpecifier')
-                  return `import {${specifier.local.name}} from ${source}`
+              .map(importSpecifier => {
+                if (importSpecifier.type === 'ImportSpecifier')
+                  return `import {${importSpecifier.local.name}} from ${source}`
                 return null
               })
               .filter(Boolean)

package/src/rules/sortedImports/CategorizedImport.ts

@@ -0,0 +1,8 @@
+import type {ImportDeclaration} from 'estree'
+import type {ImportGroup} from './ImportGroup'
+
+export interface CategorizedImport {
+  declaration: ImportDeclaration
+  group: ImportGroup
+  sortKey: string
+}

package/src/rules/sortedImports/ImportError.ts

@@ -0,0 +1,6 @@
+import type {ImportDeclaration} from 'estree'
+
+export interface ImportError {
+  node: ImportDeclaration
+  messageId: 'sortedImports' | 'sortedNames' | 'wrongGroup'
+}

package/src/rules/sortedImports/ImportGroup.ts

@@ -0,0 +1 @@
+export type ImportGroup = 'side-effect' | 'default' | 'named' | 'type'

package/src/rules/sortedImports/areSpecifiersSorted.ts

@@ -0,0 +1,10 @@
+import {getSpecifierName} from './getSpecifierName'
+import type {ImportSpecifier} from 'estree'
+
+export function areSpecifiersSorted(specifiers: ImportSpecifier[]): boolean {
+  const names = specifiers.map(s => getSpecifierName(s))
+  const sorted = [...names].sort((a, b) =>
+    a.toLowerCase().localeCompare(b.toLowerCase()),
+  )
+  return names.every((name, i) => name === sorted[i])
+}

package/src/rules/sortedImports/categorizeImport.ts

@@ -0,0 +1,15 @@
+import type {ImportGroup} from './ImportGroup'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function categorizeImport(declaration: TSESTree.ImportDeclaration): ImportGroup {
+  if (declaration.importKind === 'type')
+    return 'type'
+
+  if (declaration.specifiers.length === 0)
+    return 'side-effect'
+
+  if (declaration.specifiers.some(s => s.type === 'ImportDefaultSpecifier'))
+    return 'default'
+
+  return 'named'
+}

package/src/rules/sortedImports/categorizeImports.ts

@@ -0,0 +1,12 @@
+import {categorizeImport} from './categorizeImport'
+import {getSortKey} from './getSortKey'
+import type {CategorizedImport} from './CategorizedImport'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function categorizeImports(declarations: TSESTree.ImportDeclaration[]): CategorizedImport[] {
+  return declarations.map(declaration => ({
+    declaration,
+    group: categorizeImport(declaration),
+    sortKey: getSortKey(declaration),
+  }))
+}

package/src/rules/sortedImports/checkAlphabeticalSorting.ts

@@ -0,0 +1,22 @@
+import type {CategorizedImport} from './CategorizedImport'
+import type {ImportError} from './ImportError'
+import type {ImportGroup} from './ImportGroup'
+
+export function checkAlphabeticalSorting(categorized: CategorizedImport[]): ImportError[] {
+  const errors: ImportError[] = []
+
+  for (const group of ['side-effect', 'default', 'named', 'type'] as ImportGroup[]) {
+    const groupImports = categorized.filter(c => c.group === group)
+    const sorted = [...groupImports].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+    for (let i = 0; i < groupImports.length; i++) {
+      if (groupImports[i] !== sorted[i]) {
+        errors.push({
+          node: groupImports[i].declaration,
+          messageId: 'sortedImports',
+        })
+      }
+    }
+  }
+
+  return errors
+}

package/src/rules/sortedImports/checkGroupOrdering.ts

@@ -0,0 +1,22 @@
+import type {CategorizedImport} from './CategorizedImport'
+import type {ImportError} from './ImportError'
+import type {ImportGroup} from './ImportGroup'
+
+export function checkGroupOrdering(categorized: CategorizedImport[]): ImportError[] {
+  const groupOrder: ImportGroup[] = ['side-effect', 'default', 'named', 'type']
+  const errors: ImportError[] = []
+
+  let currentGroupIndex = -1
+  for (const {declaration, group} of categorized) {
+    const groupIndex = groupOrder.indexOf(group)
+    if (groupIndex < currentGroupIndex) {
+      errors.push({
+        node: declaration,
+        messageId: 'wrongGroup',
+      })
+    } else
+      currentGroupIndex = groupIndex
+  }
+
+  return errors
+}

package/src/rules/sortedImports/checkSpecifiersSorting.ts

@@ -0,0 +1,21 @@
+import {areSpecifiersSorted} from './areSpecifiersSorted'
+import {getNamedSpecifiers} from './getNamedSpecifiers'
+import type {CategorizedImport} from './CategorizedImport'
+import type {ImportError} from './ImportError'
+
+export function checkSpecifiersSorting(categorized: CategorizedImport[]): ImportError[] {
+  const errors: ImportError[] = []
+  const namedImports = categorized.filter(c => c.group === 'named')
+
+  for (const {declaration} of namedImports) {
+    const specifiers = getNamedSpecifiers(declaration)
+    if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+      errors.push({
+        node: declaration,
+        messageId: 'sortedNames',
+      })
+    }
+  }
+
+  return errors
+}

package/src/rules/sortedImports/createFix/ReplacementRange.ts

@@ -0,0 +1,4 @@
+export interface ReplacementRange {
+  start: number
+  end: number
+}

package/src/rules/sortedImports/createFix/buildSortedCode.ts

@@ -0,0 +1,22 @@
+import {formatNamedImport} from './formatNamedImport'
+import type {CategorizedImport} from '../CategorizedImport'
+import type {ImportGroup} from '../ImportGroup'
+
+export function buildSortedCode(
+  grouped: Record<ImportGroup, CategorizedImport[]>,
+  sourceCode: {getText: (node?: unknown) => string},
+): string[] {
+  const groupOrder: ImportGroup[] = ['side-effect', 'default', 'named', 'type']
+  const sortedCode: string[] = []
+
+  for (const group of groupOrder) {
+    for (const {declaration} of grouped[group]) {
+      if (group === 'named' || group === 'type')
+        sortedCode.push(formatNamedImport(declaration, sourceCode))
+      else
+        sortedCode.push(sourceCode.getText(declaration))
+    }
+  }
+
+  return sortedCode
+}

package/src/rules/sortedImports/createFix/findLastImportIndex.ts

@@ -0,0 +1,12 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function findLastImportIndex(programBody: TSESTree.ProgramStatement[]): number {
+  let lastIndex = 0
+  for (let i = 0; i < programBody.length; i++) {
+    if (programBody[i].type === 'ImportDeclaration')
+      lastIndex = i
+    else
+      break
+  }
+  return lastIndex
+}

package/src/rules/sortedImports/createFix/formatNamedImport.ts

@@ -0,0 +1,23 @@
+import {areSpecifiersSorted} from '../areSpecifiersSorted'
+import {getNamedSpecifiers} from '../getNamedSpecifiers'
+import {sortSpecifiersText} from '../sortSpecifiersText'
+import type {ImportDeclaration} from 'estree'
+
+export function formatNamedImport(
+  declaration: ImportDeclaration,
+  sourceCode: {getText: (node?: unknown) => string},
+): string {
+  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
+  }
+
+  return sourceCode.getText(declaration)
+}

package/src/rules/sortedImports/createFix/getReplacementRange.ts

@@ -0,0 +1,14 @@
+import {findLastImportIndex} from './findLastImportIndex'
+import type {ReplacementRange} from './ReplacementRange'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getReplacementRange(
+  programBody: TSESTree.ProgramStatement[],
+): ReplacementRange {
+  const lastIndex = findLastImportIndex(programBody)
+  const firstImport = programBody[0] as TSESTree.ImportDeclaration
+  const lastImport = programBody[lastIndex] as TSESTree.ImportDeclaration
+  const start = firstImport.range![0]
+  const end = lastImport.range![1]
+  return {start, end}
+}

package/src/rules/sortedImports/createFix/groupImportsByType.ts

@@ -0,0 +1,18 @@
+import type {CategorizedImport} from '../CategorizedImport'
+import type {ImportGroup} from '../ImportGroup'
+
+export function groupImportsByType(
+  categorized: CategorizedImport[],
+): Record<ImportGroup, CategorizedImport[]> {
+  const grouped: Record<ImportGroup, CategorizedImport[]> = {
+    'side-effect': [],
+    default: [],
+    named: [],
+    type: [],
+  }
+
+  for (const item of categorized)
+    grouped[item.group].push(item)
+
+  return grouped
+}

package/src/rules/sortedImports/createFix/index.ts

@@ -0,0 +1,28 @@
+import {buildSortedCode} from './buildSortedCode'
+import {categorizeImports} from '../categorizeImports'
+import {getReplacementRange} from './getReplacementRange'
+import {groupImportsByType} from './groupImportsByType'
+import {sortImportGroups} from './sortImportGroups'
+import type {Rule} from 'eslint'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function createFix(
+  fixer: Rule.RuleFixer,
+  importDeclarations: TSESTree.ImportDeclaration[],
+  sourceCode: {getText: (node?: unknown) => string},
+  programBody: TSESTree.ProgramStatement[],
+) {
+  const range = getReplacementRange(programBody)
+  const categorized = categorizeImports(importDeclarations)
+  const grouped = groupImportsByType(categorized)
+
+  sortImportGroups(grouped)
+
+  const sortedCode = buildSortedCode(grouped, sourceCode)
+    .join('\n')
+
+  return fixer.replaceTextRange(
+    [range.start, range.end],
+    sortedCode,
+  )
+}

package/src/rules/sortedImports/createFix/sortImportGroups.ts

@@ -0,0 +1,11 @@
+import type {CategorizedImport} from '../CategorizedImport'
+import type {ImportGroup} from '../ImportGroup'
+
+export function sortImportGroups(
+  grouped: Record<ImportGroup, CategorizedImport[]>,
+): void {
+  grouped['side-effect'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+  grouped['default'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+  grouped['named'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+  grouped['type'].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+}

package/src/rules/sortedImports/getImportDeclarations.ts

@@ -0,0 +1,8 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getImportDeclarations(programBody: TSESTree.ProgramStatement[]): TSESTree.ImportDeclaration[] {
+  return programBody.filter(
+    (statement): statement is TSESTree.ImportDeclaration =>
+      statement.type === 'ImportDeclaration',
+  )
+}

package/src/rules/sortedImports/getNamedSpecifiers.ts

@@ -0,0 +1,8 @@
+import type {ImportDeclaration} from 'estree'
+import type {ImportSpecifier} from 'estree'
+
+export function getNamedSpecifiers(declaration: ImportDeclaration): ImportSpecifier[] {
+  return declaration.specifiers.filter(
+    (s): s is ImportSpecifier => s.type === 'ImportSpecifier',
+  )
+}

package/src/rules/sortedImports/getSortKey.ts

@@ -0,0 +1,20 @@
+import {categorizeImport} from './categorizeImport'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getSortKey(declaration: TSESTree.ImportDeclaration): string {
+  const group = categorizeImport(declaration)
+
+  if (group === 'side-effect')
+    return (declaration.source.value as string).toLowerCase()
+
+  if (group === 'default') {
+    const defaultSpecifier = declaration.specifiers.find(
+      s => s.type === 'ImportDefaultSpecifier',
+    ) as TSESTree.ImportDefaultSpecifier | undefined
+
+    return defaultSpecifier?.local.name.toLowerCase() ?? ''
+  }
+
+  const specifier = declaration.specifiers[0]
+  return specifier.local.name.toLowerCase()
+}

package/src/rules/sortedImports/getSpecifierName.ts

@@ -0,0 +1,7 @@
+import type {ImportSpecifier} from 'estree'
+
+export function getSpecifierName(specifier: ImportSpecifier): string {
+  return specifier.imported.type === 'Identifier'
+    ? specifier.imported.name
+    : String(specifier.imported.value)
+}

package/src/rules/sortedImports/index.ts

@@ -0,0 +1,54 @@
+import {categorizeImports} from './categorizeImports'
+import {checkAlphabeticalSorting} from './checkAlphabeticalSorting'
+import {checkGroupOrdering} from './checkGroupOrdering'
+import {checkSpecifiersSorting} from './checkSpecifiersSorting'
+import {createFix} from './createFix'
+import {getImportDeclarations} from './getImportDeclarations'
+import type {ImportError} from './ImportError'
+import type {Rule} from 'eslint'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export const sortedImports: Rule.RuleModule = {
+  meta: {
+    docs: {
+      description: 'Enforce sorted imports alphabetically',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      sortedImports: 'Imports should be sorted alphabetically',
+      sortedNames: 'Named imports should be sorted alphabetically',
+      wrongGroup: 'Import is in wrong group',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const body = node.body as TSESTree.ProgramStatement[]
+        const declarations = getImportDeclarations(body)
+        if (declarations.length === 0)
+          return
+
+        const categorized = categorizeImports(declarations)
+        const errors: ImportError[] = [
+          ...checkGroupOrdering(categorized),
+          ...checkAlphabeticalSorting(categorized),
+          ...checkSpecifiersSorting(categorized),
+        ]
+
+        for (const error of errors) {
+          context.report({
+            node: error.node,
+            messageId: error.messageId,
+            fix(fixer) {
+              const sourceCode = context.sourceCode
+              return createFix(fixer, declarations, sourceCode, body)
+            },
+          })
+        }
+      },
+    }
+  },
+}

package/src/rules/sortedImports/sortSpecifiersText.ts

@@ -0,0 +1,14 @@
+import {getSpecifierName} from './getSpecifierName'
+import type {ImportSpecifier} from 'estree'
+
+export function sortSpecifiersText(
+  specifiers: ImportSpecifier[],
+  sourceCode: {getText: (node: ImportSpecifier) => string},
+): string {
+  const sorted = [...specifiers].sort((a, b) => {
+    const lowerA = getSpecifierName(a).toLowerCase()
+    const lowerB = getSpecifierName(b).toLowerCase()
+    return lowerA.localeCompare(lowerB)
+  })
+  return sorted.map(s => sourceCode.getText(s)).join(', ')
+}