@borela-tech/eslint-config 2.0.1 → 2.1.0

package/src/rules/importsAndReExportsAtTop/categorizeStatements.ts

@@ -0,0 +1,27 @@
+import {getStatementType} from './getStatementType'
+import {ReExport} from './ReExport'
+import type {CategorizedStatements} from './CategorizedStatements'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function categorizeStatements(
+  statements: TSESTree.Statement[],
+): CategorizedStatements {
+  const result: CategorizedStatements = {
+    imports: [],
+    reExports: [],
+    other: [],
+  }
+
+  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)
+    else
+      result.other.push(statement)
+  }
+
+  return result
+}

package/src/rules/importsAndReExportsAtTop/findFirstIndices.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 findFirstIndices(
+  statements: TSESTree.Statement[],
+): StatementIndices {
+  let firstImport = Infinity
+  let firstReExport = Infinity
+  let firstOther = -1
+
+  for (let i = 0; i < statements.length; i++) {
+    const type: StatementType = 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
+  }
+
+  return {firstImport, firstReExport, firstOther}
+}

package/src/rules/importsAndReExportsAtTop/generateSortedText.ts

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

package/src/rules/importsAndReExportsAtTop/getStatementType.ts

@@ -0,0 +1,17 @@
+import {StatementType} from './statementType'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getStatementType(statement: TSESTree.Statement): StatementType {
+  if (statement.type === 'ImportDeclaration')
+    return 'import'
+
+  if (statement.type === 'ExportAllDeclaration')
+    return 're-export'
+
+  if (statement.type === 'ExportNamedDeclaration') {
+    if (statement.source !== null)
+      return 're-export'
+  }
+
+  return 'other'
+}

package/src/rules/importsAndReExportsAtTop/hasViolation.ts

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

package/src/rules/importsAndReExportsAtTop/index.ts

@@ -0,0 +1,45 @@
+import {categorizeStatements} from './categorizeStatements'
+import {findFirstIndices} from './findFirstIndices'
+import {generateSortedText} from './generateSortedText'
+import {hasViolation} from './hasViolation'
+import type {Rule} from 'eslint'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export const importsAndReExportsAtTop: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce imports and re-exports at the top of the file',
+      recommended: false,
+    },
+    fixable: 'code',
+    messages: {
+      importsAndReExportsAtTop:
+        'Imports and re-exports should be at the top of the file.',
+    },
+    schema: [],
+  },
+
+  create(context) {
+    return {
+      Program(node) {
+        const statements = node.body as TSESTree.Statement[]
+        const categories = categorizeStatements(statements)
+        const indices = findFirstIndices(statements)
+
+        if (!hasViolation(indices, categories))
+          return
+
+        context.report({
+          node,
+          messageId: 'importsAndReExportsAtTop',
+
+          fix(fixer) {
+            const sortedText = generateSortedText(context, categories)
+            return fixer.replaceText(node, sortedText)
+          },
+        })
+      },
+    }
+  },
+}

package/src/rules/importsAndReExportsAtTop/statementType.ts

@@ -0,0 +1,4 @@
+export type StatementType =
+  | 'import'
+  | 'other'
+  | 're-export'

package/src/rules/individualImports.ts

@@ -18,26 +18,17 @@ export const individualImports: Rule.RuleModule = {
       ImportDeclaration(node) {
         if (node.specifiers.length <= 1)
           return
+
         context.report({
           node,
           messageId: 'individualImports',
           fix(fixer) {
             const source = node.source.raw
             const specifiers = node.specifiers
-              .map(importSpecifier => {
-                if (importSpecifier.type === 'ImportSpecifier')
-                  return `import {${importSpecifier.local.name}} from ${source}`
-                return null
-              })
-              .filter(Boolean)
-
-            if (specifiers.length !== node.specifiers.length)
-              return null
-
-            return fixer.replaceText(
-              node,
-              specifiers.join('\n'),
-            )
+              .filter(s => s.type === 'ImportSpecifier')
+              .map(s => `import {${s.local.name}} from ${source}`)
+              .join('\n')
+            return fixer.replaceText(node, specifiers)
           },
         })
       },

package/src/rules/individualReExports.ts

@@ -0,0 +1,52 @@
+import type {Rule} from 'eslint'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export const individualReExports: Rule.RuleModule = {
+  meta: {
+    docs: {
+      description: 'Enforce individual exports instead of grouped exports',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      individualReExports: 'Use individual exports instead of grouped exports.',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  create(context) {
+    return {
+      ExportNamedDeclaration(node) {
+        const exportNode = node as TSESTree.ExportNamedDeclaration
+        if (!exportNode.source || exportNode.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 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}`
+                return `export ${typeKeyword}{${name}} from '${source}'`
+              })
+              .join('\n')
+            return fixer.replaceText(node, specifiers)
+          },
+        })
+      },
+    }
+  },
+}

package/src/rules/sortedImports/CategorizedImport.ts

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

package/src/rules/sortedImports/ImportError.ts

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

package/src/rules/sortedImports/ImportGroup.ts

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

package/src/rules/sortedImports/ImportGroupOrder.ts

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

package/src/rules/sortedImports/areSpecifiersSorted.ts

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

package/src/rules/sortedImports/categorizeImport.ts

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

package/src/rules/sortedImports/checkAlphabeticalSorting.ts

@@ -1,13 +1,14 @@
+import {compare} from '../../lib/compare'
+import {importGroupOrder} from './ImportGroupOrder'
 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[]) {
+  for (const group of importGroupOrder) {
     const groupImports = categorized.filter(c => c.group === group)
-    const sorted = [...groupImports].sort((a, b) => a.sortKey.localeCompare(b.sortKey))
+    const sorted = [...groupImports].sort((a, b) => compare(a.sortKey, b.sortKey))
     for (let i = 0; i < groupImports.length; i++) {
       if (groupImports[i] !== sorted[i]) {
         errors.push({

package/src/rules/sortedImports/checkGroupOrdering.ts

@@ -1,14 +1,13 @@
+import {importGroupOrder} from './ImportGroupOrder'
 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)
+    const groupIndex = importGroupOrder.indexOf(group)
     if (groupIndex < currentGroupIndex) {
       errors.push({
         node: declaration,

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

@@ -1,4 +1,5 @@
 import {formatNamedImport} from './formatNamedImport'
+import {importGroupOrder} from '../ImportGroupOrder'
 import type {CategorizedImport} from '../CategorizedImport'
 import type {ImportGroup} from '../ImportGroup'
 
@@ -6,10 +7,9 @@ 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 group of importGroupOrder) {
     for (const {declaration} of grouped[group]) {
       if (group === 'named' || group === 'type')
         sortedCode.push(formatNamedImport(declaration, sourceCode))

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

@@ -1,22 +1,19 @@
 import {areSpecifiersSorted} from '../areSpecifiersSorted'
 import {getNamedSpecifiers} from '../getNamedSpecifiers'
 import {sortSpecifiersText} from '../sortSpecifiersText'
-import type {ImportDeclaration} from 'estree'
+import type {TSESTree} from '@typescript-eslint/types'
 
 export function formatNamedImport(
-  declaration: ImportDeclaration,
+  declaration: TSESTree.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
+    const source = declaration.source.value
+    const prefix = declaration.importKind === 'type' ? 'import type ' : 'import '
+    return `${prefix}{${sortedSpecifiers}} from '${source}'`
   }
 
   return sourceCode.getText(declaration)

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

@@ -1,5 +1,5 @@
 import {findLastImportIndex} from './findLastImportIndex'
-import type {ReplacementRange} from './ReplacementRange'
+import type {ReplacementRange} from '../../../lib/ReplacementRange'
 import type {TSESTree} from '@typescript-eslint/types'
 
 export function getReplacementRange(

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

@@ -1,11 +1,12 @@
+import {compare} from '../../../lib/compare'
 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))
+  grouped['side-effect'].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))
 }

package/src/rules/sortedImports/getNamedSpecifiers.ts

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

package/src/rules/sortedImports/getSortKey.ts

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

package/src/rules/sortedImports/getSpecifierName.ts

@@ -1,6 +1,6 @@
-import type {ImportSpecifier} from 'estree'
+import type {TSESTree} from '@typescript-eslint/types'
 
-export function getSpecifierName(specifier: ImportSpecifier): string {
+export function getSpecifierName(specifier: TSESTree.ImportSpecifier): string {
   return specifier.imported.type === 'Identifier'
     ? specifier.imported.name
     : String(specifier.imported.value)

package/src/rules/sortedImports/sortSpecifiersText.ts

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

package/src/rules/sortedReExports/CategorizedNamedReExport.ts

@@ -0,0 +1,6 @@
+import type {CategorizedReExport} from './CategorizedReExport'
+
+export type CategorizedNamedReExport = Extract<
+  CategorizedReExport,
+  {declaration: {type: 'ExportNamedDeclaration'}}
+>

package/src/rules/sortedReExports/CategorizedReExport.ts

@@ -0,0 +1,15 @@
+import {TSESTree} from '@typescript-eslint/types'
+
+interface NamedReExport {
+  declaration: TSESTree.ExportNamedDeclaration
+  group: 're-export-named' | 're-export-type'
+  sortKey: string
+}
+
+interface ReExportAll {
+  declaration: TSESTree.ExportAllDeclaration
+  group: 're-export-all'
+  sortKey: string
+}
+
+export type CategorizedReExport = NamedReExport | ReExportAll

package/src/rules/sortedReExports/ReExportDeclaration.ts

@@ -0,0 +1,5 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export type ReExportDeclaration =
+  | TSESTree.ExportAllDeclaration
+  | TSESTree.ExportNamedDeclaration

package/src/rules/sortedReExports/ReExportError.ts

@@ -0,0 +1,6 @@
+import type {ReExportDeclaration} from './ReExportDeclaration'
+
+export interface ReExportError {
+  node: ReExportDeclaration
+  messageId: 'sortedReExports' | 'sortedNames' | 'wrongGroup'
+}

package/src/rules/sortedReExports/ReExportGroup.ts

@@ -0,0 +1,4 @@
+export type ReExportGroup =
+  | 're-export-all'
+  | 're-export-named'
+  | 're-export-type'

package/src/rules/sortedReExports/ReExportGroupOrder.ts

@@ -0,0 +1,7 @@
+import {ReExportGroup} from './ReExportGroup'
+
+export const reExportGroupOrder: ReExportGroup[] = [
+  're-export-all',
+  're-export-named',
+  're-export-type',
+]

package/src/rules/sortedReExports/areSpecifiersSorted.ts

@@ -0,0 +1,9 @@
+import {compare} from '../../lib/compare'
+import {getSpecifierName} from './getSpecifierName'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function areSpecifiersSorted(specifiers: TSESTree.ExportSpecifier[]): boolean {
+  const names = specifiers.map(s => getSpecifierName(s))
+  const sorted = [...names].sort((a, b) => compare(a, b))
+  return names.every((name, i) => name === sorted[i])
+}

package/src/rules/sortedReExports/categorizeReExport.ts

@@ -0,0 +1,17 @@
+import type {ReExportGroup} from './ReExportGroup'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function categorizeReExport(
+  declaration: TSESTree.ExportNamedDeclaration | TSESTree.ExportAllDeclaration,
+): ReExportGroup {
+  // Example: export * from 'module'
+  if (declaration.type === 'ExportAllDeclaration')
+    return 're-export-all'
+
+  // Example: export type {Type} from 'module'
+  if (declaration.exportKind === 'type')
+    return 're-export-type'
+
+  // Example: export {value} from 'module'
+  return 're-export-named'
+}

package/src/rules/sortedReExports/categorizeReExports.ts

@@ -0,0 +1,14 @@
+import {categorizeReExport} from './categorizeReExport'
+import {getSortKey} from './getSortKey'
+import {ReExportDeclaration} from './ReExportDeclaration'
+import type {CategorizedReExport} from './CategorizedReExport'
+
+export function categorizeReExports(declarations: ReExportDeclaration[]): CategorizedReExport[] {
+  return declarations.map(declaration => {
+    return {
+      declaration,
+      group: categorizeReExport(declaration),
+      sortKey: getSortKey(declaration),
+    } as CategorizedReExport
+  })
+}

package/src/rules/sortedReExports/checkAlphabeticalSorting.ts

@@ -0,0 +1,25 @@
+import {compare} from '../../lib/compare'
+import {reExportGroupOrder} from './ReExportGroupOrder'
+import type {CategorizedReExport} from './CategorizedReExport'
+import type {ReExportError} from './ReExportError'
+
+export function checkAlphabeticalSorting(categorized: CategorizedReExport[]): ReExportError[] {
+  const errors: ReExportError[] = []
+
+  for (const group of reExportGroupOrder) {
+    const groupReExports = categorized.filter(c => c.group === group)
+    const sorted = [...groupReExports].sort((a, b) =>
+      compare(a.sortKey, b.sortKey),
+    )
+    for (let i = 0; i < groupReExports.length; i++) {
+      if (groupReExports[i] !== sorted[i]) {
+        errors.push({
+          node: groupReExports[i].declaration,
+          messageId: 'sortedReExports',
+        })
+      }
+    }
+  }
+
+  return errors
+}