@borela-tech/eslint-config 2.0.1 → 2.1.0

package/src/rules/sortedReExports/checkGroupOrdering.ts

@@ -0,0 +1,21 @@
+import {reExportGroupOrder} from './ReExportGroupOrder'
+import type {CategorizedReExport} from './CategorizedReExport'
+import type {ReExportError} from './ReExportError'
+
+export function checkGroupOrdering(categorized: CategorizedReExport[]): ReExportError[] {
+  const errors: ReExportError[] = []
+
+  let currentGroupIndex = -1
+  for (const {declaration, group} of categorized) {
+    const groupIndex = reExportGroupOrder.indexOf(group)
+    if (groupIndex < currentGroupIndex) {
+      errors.push({
+        node: declaration,
+        messageId: 'wrongGroup',
+      })
+    } else
+      currentGroupIndex = groupIndex
+  }
+
+  return errors
+}

package/src/rules/sortedReExports/checkSpecifiersSorting.ts

@@ -0,0 +1,23 @@
+import {areSpecifiersSorted} from './areSpecifiersSorted'
+import {getNamedSpecifiers} from './getNamedSpecifiers'
+import {isNamedReExport} from './isNamedReExport'
+import type {CategorizedReExport} from './CategorizedReExport'
+import type {ReExportError} from './ReExportError'
+
+export function checkSpecifiersSorting(categorized: CategorizedReExport[]): ReExportError[] {
+  const errors: ReExportError[] = []
+  const namedReExports = categorized.filter(isNamedReExport)
+
+  for (const {declaration} of namedReExports) {
+    const specifiers = getNamedSpecifiers(declaration)
+    const isSorted = areSpecifiersSorted(specifiers)
+    if (specifiers.length > 1 && !isSorted) {
+      errors.push({
+        node: declaration,
+        messageId: 'sortedNames',
+      })
+    }
+  }
+
+  return errors
+}

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

@@ -0,0 +1,28 @@
+import {formatNamedReExport} from './formatNamedReExport'
+import {isNamedReExport} from '../isNamedReExport'
+import {reExportGroupOrder} from '../ReExportGroupOrder'
+import type {CategorizedReExport} from '../CategorizedReExport'
+import type {ReExportGroup} from '../ReExportGroup'
+
+export function buildSortedCode(
+  grouped: Record<ReExportGroup, CategorizedReExport[]>,
+  sourceCode: {getText: (node?: unknown) => string},
+): string[] {
+  const sortedCode: string[] = []
+
+  for (const group of reExportGroupOrder) {
+    for (const item of grouped[group]) {
+      if (isNamedReExport(item)) {
+        sortedCode.push(
+          formatNamedReExport(
+            item.declaration,
+            sourceCode,
+          ),
+        )
+      } else
+        sortedCode.push(sourceCode.getText(item.declaration))
+    }
+  }
+
+  return sortedCode
+}

package/src/rules/sortedReExports/createFix/findFirstExportIndex.ts

@@ -0,0 +1,11 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function findFirstExportIndex(programBody: TSESTree.ProgramStatement[]): number {
+  for (let i = 0; i < programBody.length; i++) {
+    if (programBody[i].type === 'ExportNamedDeclaration'
+      || programBody[i].type === 'ExportAllDeclaration') {
+      return i
+    }
+  }
+  return -1
+}

package/src/rules/sortedReExports/createFix/findLastExportIndex.ts

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

package/src/rules/sortedReExports/createFix/formatNamedReExport.ts

@@ -0,0 +1,20 @@
+import {areSpecifiersSorted} from '../areSpecifiersSorted'
+import {getNamedSpecifiers} from '../getNamedSpecifiers'
+import {sortSpecifiersText} from '../sortSpecifiersText'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function formatNamedReExport(
+  declaration: TSESTree.ExportNamedDeclaration,
+  sourceCode: {getText: (node?: unknown) => string},
+): string {
+  const specifiers = getNamedSpecifiers(declaration)
+
+  if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
+    const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode)
+    const source = declaration.source!.value
+    const prefix = declaration.exportKind === 'type' ? 'export type ' : 'export '
+    return `${prefix}{${sortedSpecifiers}} from '${source}'`
+  }
+
+  return sourceCode.getText(declaration)
+}

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

@@ -0,0 +1,22 @@
+import {findFirstExportIndex} from './findFirstExportIndex'
+import {findLastExportIndex} from './findLastExportIndex'
+import type {ReplacementRange} from '../../../lib/ReplacementRange'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getReplacementRange(
+  programBody: TSESTree.ProgramStatement[],
+): ReplacementRange {
+  const firstIndex = findFirstExportIndex(programBody)
+  const lastIndex = findLastExportIndex(programBody)
+
+  if (firstIndex === -1 || lastIndex === -1)
+    return {start: 0, end: 0}
+
+  const firstExport = programBody[firstIndex]
+  const lastExport = programBody[lastIndex]
+
+  const start = firstExport.range[0]
+  const end = lastExport.range[1]
+
+  return {start, end}
+}

package/src/rules/sortedReExports/createFix/groupReExportsByType.ts

@@ -0,0 +1,17 @@
+import type {CategorizedReExport} from '../CategorizedReExport'
+import type {ReExportGroup} from '../ReExportGroup'
+
+export function groupReExportsByType(
+  categorized: CategorizedReExport[],
+): Record<ReExportGroup, CategorizedReExport[]> {
+  const grouped: Record<ReExportGroup, CategorizedReExport[]> = {
+    're-export-all': [],
+    're-export-named': [],
+    're-export-type': [],
+  }
+
+  for (const item of categorized)
+    grouped[item.group].push(item)
+
+  return grouped
+}

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

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

package/src/rules/sortedReExports/createFix/sortExportGroups.ts

@@ -0,0 +1,11 @@
+import {compare} from '../../../lib/compare'
+import type {CategorizedReExport} from '../CategorizedReExport'
+import type {ReExportGroup} from '../ReExportGroup'
+
+export function sortExportGroups(
+  grouped: Record<ReExportGroup, CategorizedReExport[]>,
+): void {
+  grouped['re-export-all'].sort((a, b) => compare(a.sortKey, b.sortKey))
+  grouped['re-export-named'].sort((a, b) => compare(a.sortKey, b.sortKey))
+  grouped['re-export-type'].sort((a, b) => compare(a.sortKey, b.sortKey))
+}

package/src/rules/sortedReExports/getNamedSpecifiers.ts

@@ -0,0 +1,9 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getNamedSpecifiers(
+  declaration: TSESTree.ExportNamedDeclaration,
+): TSESTree.ExportSpecifier[] {
+  return declaration.specifiers.filter(
+    s => s.type === 'ExportSpecifier' && s.local.type === 'Identifier',
+  ) as TSESTree.ExportSpecifier[]
+}

package/src/rules/sortedReExports/getReExportDeclarations.ts

@@ -0,0 +1,12 @@
+import type {ReExportDeclaration} from './ReExportDeclaration'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getReExportDeclarations(
+  programBody: TSESTree.ProgramStatement[],
+): ReExportDeclaration[] {
+  return programBody.filter(
+    (statement): statement is ReExportDeclaration =>
+      (statement.type === 'ExportNamedDeclaration' && statement.source !== null)
+      || statement.type === 'ExportAllDeclaration',
+  )
+}

package/src/rules/sortedReExports/getSortKey.ts

@@ -0,0 +1,16 @@
+import type {TSESTree} from '@typescript-eslint/types'
+
+export function getSortKey(
+  declaration: TSESTree.ExportNamedDeclaration | TSESTree.ExportAllDeclaration,
+): string {
+  if (declaration.type === 'ExportAllDeclaration')
+    return declaration.source.value
+
+  const specifier = declaration.specifiers[0]
+  if (!specifier)
+    return ''
+
+  return specifier.local.type === 'Identifier'
+    ? specifier.local.name
+    : specifier.local.value
+}

package/src/rules/sortedReExports/getSpecifierName.ts

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

package/src/rules/sortedReExports/index.ts

@@ -0,0 +1,54 @@
+import {categorizeReExports} from './categorizeReExports'
+import {checkAlphabeticalSorting} from './checkAlphabeticalSorting'
+import {checkGroupOrdering} from './checkGroupOrdering'
+import {checkSpecifiersSorting} from './checkSpecifiersSorting'
+import {createFix} from './createFix'
+import {getReExportDeclarations} from './getReExportDeclarations'
+import type {ReExportError} from './ReExportError'
+import type {Rule} from 'eslint'
+import type {TSESTree} from '@typescript-eslint/types'
+
+export const sortedReExports: Rule.RuleModule = {
+  meta: {
+    docs: {
+      description: 'Enforce sorted exports alphabetically',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      sortedReExports: 'Exports should be sorted alphabetically',
+      sortedNames: 'Named exports should be sorted alphabetically',
+      wrongGroup: 'Export is in wrong group',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const body = node.body as TSESTree.ProgramStatement[]
+        const declarations = getReExportDeclarations(body)
+        if (declarations.length === 0)
+          return
+
+        const categorized = categorizeReExports(declarations)
+        const errors: ReExportError[] = [
+          ...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/sortedReExports/isNamedReExport.ts

@@ -0,0 +1,6 @@
+import {CategorizedNamedReExport} from './CategorizedNamedReExport'
+import type {CategorizedReExport} from './CategorizedReExport'
+
+export function isNamedReExport(x: CategorizedReExport): x is CategorizedNamedReExport {
+  return x.group !== 're-export-all'
+}

package/src/rules/sortedReExports/sortSpecifiersText.ts

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