@borela-tech/eslint-config 2.2.2 → 2.3.0

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

@@ -1,220 +0,0 @@
-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,
-    parserOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  },
-})
-
-ruleTester.run('sorted-re-exports', rule, {
-  valid: [{
-    code: 'export const foo = 42',
-  }, {
-    code: 'export function bar() {}',
-  }, {
-    code: 'export {foo}',
-  }, {
-    code: "export {foo} from 'bar'",
-  }, {
-    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'
-      export type {Y} from 'yyy'
-    `,
-  }, {
-    code: dedent`
-      export {a, b, c} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      export const foo = 42
-      export {bar} from 'baz'
-    `,
-  }, {
-    code: dedent`
-      function foo() {}
-      export {foo}
-      export * from 'bar'
-    `,
-  }, {
-    code: dedent`
-      export * from 'bbb'
-      export {a} from 'aaa'
-    `,
-  }, {
-    code: dedent`
-      export const z = 1
-      export {a} from 'bar'
-      export function foo() {}
-      export {b} from 'baz'
-      export class Bar {}
-    `,
-  }, {
-    code: dedent`
-      export class Child extends Parent {}
-      export class Parent {}
-      export {child} from 'child-module'
-    `,
-  }, {
-    code: dedent`
-      export {a} from 'aaa'
-      export const c = 3
-      export {x} from 'xxx'
-      export const b = 2
-      export {z} from 'zzz'
-    `,
-  }, {
-    code: '',
-  }, {
-    code: 'const x = 1',
-  }],
-  invalid: [{
-    code: dedent`
-      export {c, a, b} from 'bar'
-    `,
-    errors: [{messageId: 'sortedNames'}],
-    output: dedent`
-      export {a, b, c} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      export {b} from 'b'
-      const x = 1
-      export {c} from 'c'
-      export {a} from 'a'
-    `,
-    errors: [{messageId: 'sortedReExports'}, {messageId: 'sortedReExports'}],
-    output: dedent`
-      export {b} from 'b'
-      const x = 1
-      export {a} from 'a'
-      export {c} from 'c'
-    `,
-  }, {
-    code: dedent`
-      export {b} from 'b'
-      export {a} from 'a'
-      const x = 1
-      export {d} from 'd'
-      export {c} from 'c'
-      const y = 2
-      export {f} from 'f'
-      export {e} from 'e'
-    `,
-    errors: [
-      {messageId: 'sortedReExports'},
-      {messageId: 'sortedReExports'},
-      {messageId: 'sortedReExports'},
-      {messageId: 'sortedReExports'},
-      {messageId: 'sortedReExports'},
-      {messageId: 'sortedReExports'},
-    ],
-    output: dedent`
-      export {a} from 'a'
-      export {b} from 'b'
-      const x = 1
-      export {c} from 'c'
-      export {d} from 'd'
-      const y = 2
-      export {e} from 'e'
-      export {f} from 'f'
-    `,
-  }, {
-    code: dedent`
-      export {z, a} from 'bar'
-    `,
-    errors: [{messageId: 'sortedNames'}],
-    output: dedent`
-      export {a, z} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      export * from 'bbb'
-      export * from 'aaa'
-    `,
-    errors: [{messageId: 'sortedReExports'}, {messageId: 'sortedReExports'}],
-    output: dedent`
-      export * from 'aaa'
-      export * from 'bbb'
-    `,
-  }, {
-    code: dedent`
-      export type {Y} from 'yyy'
-      export type {X} from 'xxx'
-    `,
-    errors: [{messageId: 'sortedReExports'}, {messageId: 'sortedReExports'}],
-    output: dedent`
-      export type {X} from 'xxx'
-      export type {Y} from 'yyy'
-    `,
-  }, {
-    code: dedent`
-      export {a} from 'bar'
-      export * from 'aaa'
-    `,
-    errors: [{messageId: 'wrongGroup'}],
-    output: dedent`
-      export * from 'aaa'
-      export {a} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      export {b, a} from 'bar'
-      export * from 'aaa'
-    `,
-    errors: [{messageId: 'sortedNames'}, {messageId: 'wrongGroup'}],
-    output: dedent`
-      export * from 'aaa'
-      export {a, b} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      export {existsSync} from 'fs'
-      export {basename} from 'path'
-    `,
-    errors: [{messageId: 'sortedReExports'}, {messageId: 'sortedReExports'}],
-    output: dedent`
-      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 +0,0 @@
-import type {ReExportDeclaration} from '@lib/ReExportDeclaration'
-import type {TSESTree} from '@typescript-eslint/types'
-
-export interface CategorizedStatements {
-  imports: TSESTree.ImportDeclaration[]
-  reExports: ReExportDeclaration[]
-  other: TSESTree.Statement[]
-}

package/src/rules/importsAndReExportsAtTop/StatementIndices.ts

@@ -1,5 +0,0 @@
-export interface StatementIndices {
-  firstRegularStatement: number
-  lastImport: number
-  lastReExport: number
-}

package/src/rules/importsAndReExportsAtTop/categorizeStatements.ts

@@ -1,28 +0,0 @@
-import {getStatementType} from './getStatementType'
-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.ProgramStatement[],
-): CategorizedStatements {
-  const result: CategorizedStatements = {
-    imports: [],
-    reExports: [],
-    other: [],
-  }
-
-  for (const statement of statements) {
-    const type = getStatementType(statement)
-
-    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)
-  }
-
-  return result
-}

package/src/rules/importsAndReExportsAtTop/findStatementIndices.ts

@@ -1,25 +0,0 @@
-import {getStatementType} from './getStatementType'
-import type {StatementIndices} from './StatementIndices'
-import type {StatementType} from './statementType'
-import type {TSESTree} from '@typescript-eslint/types'
-
-export function findStatementIndices(
-  statements: TSESTree.Statement[],
-): StatementIndices {
-  let firstRegularStatement = -1
-  let lastImport = -1
-  let lastReExport = -1
-
-  for (let i = 0; i < statements.length; i++) {
-    const type: StatementType = getStatementType(statements[i])
-
-    if (type === 'import')
-      lastImport = i
-    else if (type === 're-export')
-      lastReExport = i
-    else if (type === 'other' && firstRegularStatement === -1)
-      firstRegularStatement = i
-  }
-
-  return {firstRegularStatement, lastImport, lastReExport}
-}

package/src/rules/importsAndReExportsAtTop/generateSortedText.ts

@@ -1,16 +0,0 @@
-import type {CategorizedStatements} from './CategorizedStatements'
-import type {TSESLint} from '@typescript-eslint/utils'
-
-export function generateSortedText(
-  context: TSESLint.RuleContext<'importsAndReExportsAtTop', []>,
-  categories: CategorizedStatements,
-): string {
-  const allStatements = [
-    ...categories.imports,
-    ...categories.reExports,
-    ...categories.other,
-  ]
-  return allStatements.map(
-    node => context.sourceCode.getText(node),
-  ).join('\n')
-}

package/src/rules/importsAndReExportsAtTop/getStatementType.ts

@@ -1,17 +0,0 @@
-import type {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

@@ -1,25 +0,0 @@
-import type {CategorizedStatements} from './CategorizedStatements'
-import type {StatementIndices} from './StatementIndices'
-
-export function hasViolation(
-  indices: StatementIndices,
-  categories: CategorizedStatements,
-): boolean {
-  const {firstRegularStatement, lastImport, lastReExport} = indices
-
-  if (categories.imports.length === 0 && categories.reExports.length === 0)
-    return false
-
-  const hasImportAfterRegularStatement = (
-    categories.imports.length > 0
-    && firstRegularStatement !== -1
-    && lastImport > firstRegularStatement
-  )
-  const hasReExportAfterRegularStatement = (
-    categories.reExports.length > 0
-    && firstRegularStatement !== -1
-    && lastReExport > firstRegularStatement
-  )
-
-  return hasImportAfterRegularStatement || hasReExportAfterRegularStatement
-}

package/src/rules/importsAndReExportsAtTop/index.ts

@@ -1,45 +0,0 @@
-import {categorizeStatements} from './categorizeStatements'
-import {findStatementIndices} from './findStatementIndices'
-import {generateSortedText} from './generateSortedText'
-import {hasViolation} from './hasViolation'
-import type {TSESLint} from '@typescript-eslint/utils'
-
-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',
-    },
-    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
-        const categories = categorizeStatements(statements)
-        const indices = findStatementIndices(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/isImportDeclaration.ts

@@ -1,7 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/importsAndReExportsAtTop/statementType.ts

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

package/src/rules/individualImports.ts

@@ -1,38 +0,0 @@
-import type {TSESLint} from '@typescript-eslint/utils'
-
-type MessageIds = 'individualImports'
-
-export const individualImports: TSESLint.RuleModule<MessageIds, []> = {
-  meta: {
-    docs: {
-      description: 'Enforce individual imports instead of grouped imports',
-    },
-    fixable: 'code',
-    messages: {
-      individualImports: 'Use individual imports instead of grouped imports.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  create(context) {
-    return {
-      ImportDeclaration(node) {
-        if (node.specifiers.length <= 1)
-          return
-
-        context.report({
-          node,
-          messageId: 'individualImports',
-          fix(fixer) {
-            const source = node.source.raw
-            const specifiers = node.specifiers
-              .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

@@ -1,51 +0,0 @@
-import type {TSESLint} from '@typescript-eslint/utils'
-
-type MessageIds = 'individualReExports'
-
-export const individualReExports: TSESLint.RuleModule<MessageIds, []> = {
-  meta: {
-    docs: {
-      description: 'Enforce individual exports instead of grouped exports',
-    },
-    fixable: 'code',
-    messages: {
-      individualReExports: 'Use individual exports instead of grouped exports.',
-    },
-    schema: [],
-    type: 'suggestion',
-  },
-  create(context) {
-    return {
-      ExportNamedDeclaration(node) {
-        if (!node.source || node.specifiers.length <= 1)
-          return
-
-        context.report({
-          node,
-          messageId: 'individualReExports',
-          fix(fixer) {
-            const source = node.source.value
-            const typeKeyword = node.exportKind === 'type'
-              ? 'type '
-              : ''
-            const specifiers = node.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/multilineUnionTypes/createFix.ts

@@ -1,13 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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)}}`
-}