@borela-tech/eslint-config 2.2.1 → 2.3.0

package/src/index.ts

@@ -1,149 +0,0 @@
-import eslint from '@eslint/js'
-import react from 'eslint-plugin-react'
-import reactHooks from 'eslint-plugin-react-hooks'
-import stylistic from '@stylistic/eslint-plugin'
-import typescript from 'typescript-eslint'
-import {importsAndReExportsAtTop} from './rules/importsAndReExportsAtTop'
-import {individualImports} from './rules/individualImports'
-import {individualReExports} from './rules/individualReExports'
-import {multilineUnionTypes} from './rules/multilineUnionTypes'
-import {singleLineImports} from './rules/singleLineImports'
-import {singleLineReExports} from './rules/singleLineReExports'
-import {sortedImports} from './rules/sortedImports'
-import {sortedReExports} from './rules/sortedReExports'
-import type {TSESLint} from '@typescript-eslint/utils'
-
-export const CONFIG: TSESLint.FlatConfig.ConfigArray = [
-  {
-    ignores: [
-      'src/graphql/sdk.ts',
-      '**/node_modules/**',
-      '**/dist/**',
-    ],
-  },
-  {
-    settings: {
-      react: {
-        version: '19',
-      },
-    },
-  },
-  eslint.configs.recommended,
-  react.configs.flat.recommended,
-  stylistic.configs.recommended,
-  ...typescript.configs.recommended,
-  ...typescript.configs.stylistic,
-  {
-    plugins: {
-      'react-hooks': reactHooks,
-    },
-    rules: reactHooks.configs.recommended.rules,
-  },
-  {
-    plugins: {
-      '@borela-tech': {
-        rules: {
-          'imports-and-re-exports-at-top': importsAndReExportsAtTop,
-          'individual-imports': individualImports,
-          'individual-re-exports': individualReExports,
-          'multiline-union-types': multilineUnionTypes,
-          'single-line-imports': singleLineImports,
-          'single-line-re-exports': singleLineReExports,
-          'sorted-imports': sortedImports,
-          'sorted-re-exports': sortedReExports,
-        },
-      },
-    },
-    rules: {
-      '@borela-tech/imports-and-re-exports-at-top': 'error',
-      '@borela-tech/individual-imports': 'error',
-      '@borela-tech/individual-re-exports': 'error',
-      '@borela-tech/multiline-union-types': 'error',
-      '@borela-tech/single-line-imports': 'error',
-      '@borela-tech/single-line-re-exports': 'error',
-      '@borela-tech/sorted-imports': 'error',
-      '@borela-tech/sorted-re-exports': 'error',
-    },
-  },
-  {
-    rules: {
-      'capitalized-comments': [
-        'error',
-        'always',
-        {ignoreConsecutiveComments: true},
-      ],
-      'react/react-in-jsx-scope': 'off',
-      '@stylistic/arrow-parens': [
-        'error',
-        'as-needed',
-      ],
-      '@stylistic/array-bracket-newline': [
-        'error',
-        'consistent',
-      ],
-      '@stylistic/array-bracket-spacing': [
-        'error',
-        'never',
-      ],
-      '@stylistic/array-element-newline': [
-        'error',
-        'consistent',
-      ],
-      '@stylistic/block-spacing': 'off',
-      '@stylistic/brace-style': [
-        'error',
-        '1tbs',
-        {allowSingleLine: true},
-      ],
-      '@stylistic/indent': [
-        'error',
-        2,
-        {ignoredNodes: ['TSMappedType > *']},
-      ],
-      '@stylistic/jsx-tag-spacing': [
-        'error',
-        {
-          afterOpening: 'never',
-          beforeClosing: 'never',
-          beforeSelfClosing: 'never',
-          closingSlash: 'never',
-        },
-      ],
-      '@stylistic/jsx-wrap-multilines': 'off',
-      '@stylistic/lines-between-class-members': 'off',
-      '@stylistic/object-curly-newline': [
-        'error',
-        {consistent: true},
-      ],
-      '@stylistic/object-curly-spacing': [
-        'error',
-        'never',
-      ],
-      '@stylistic/operator-linebreak': [
-        'error',
-        'before',
-        {overrides: {'=': 'after'}},
-      ],
-      '@stylistic/quotes': [
-        'error',
-        'single',
-        {avoidEscape: true},
-      ],
-      '@stylistic/quote-props': [
-        'error',
-        'as-needed',
-      ],
-      '@stylistic/semi': [
-        'error',
-        'never',
-        {beforeStatementContinuationChars: 'always'},
-      ],
-      '@typescript-eslint/no-empty-function': 'off',
-      '@typescript-eslint/consistent-indexed-object-style': 'off',
-      '@typescript-eslint/consistent-type-imports': [
-        'error',
-        {fixStyle: 'separate-type-imports'},
-      ],
-    },
-  },
-]

package/src/lib/ReExportDeclaration.ts

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

package/src/lib/ReplacementRange.ts

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

package/src/lib/compare.ts

@@ -1,3 +0,0 @@
-export function compare(a: string, b: string): number {
-  return a.localeCompare(b, 'en', {sensitivity: 'case'})
-}

package/src/rules/__tests__/dedent/countLeadingSpaces.ts

@@ -1,4 +0,0 @@
-export function countLeadingSpaces(line: string): number {
-  const match = line.match(/^(\s*)/)
-  return match ? match[1].length : 0
-}

package/src/rules/__tests__/dedent/findMinIndent.ts

@@ -1,7 +0,0 @@
-import {countLeadingSpaces} from './countLeadingSpaces'
-
-export function findMinIndent(lines: string[]): number {
-  const nonEmptyLines = lines.filter(line => line.trim().length > 0)
-  const indents = nonEmptyLines.map(line => countLeadingSpaces(line))
-  return Math.min(...indents)
-}

package/src/rules/__tests__/dedent/index.ts

@@ -1,17 +0,0 @@
-import {findMinIndent} from './findMinIndent'
-import {interpolate} from './interpolate'
-import {removeEmptyPrefix} from './removeEmptyPrefix'
-import {removeEmptySuffix} from './removeEmptySuffix'
-import {removeIndent} from './removeIndent'
-
-export function dedent(
-  strings: TemplateStringsArray,
-  ...values: unknown[]
-): string {
-  const raw = interpolate(strings, values)
-  const lines = raw.split('\n')
-  const withoutPrefix = removeEmptyPrefix(lines)
-  const trimmed = removeEmptySuffix(withoutPrefix)
-  const indentSize = findMinIndent(trimmed)
-  return removeIndent(trimmed, indentSize)
-}

package/src/rules/__tests__/dedent/interpolate.ts

@@ -1,11 +0,0 @@
-export function interpolate(
-  strings: TemplateStringsArray,
-  values: unknown[],
-): string {
-  let result = ''
-  for (let i = 0; i < strings.length; i++) {
-    result += strings[i]
-    if (i < values.length) result += String(values[i])
-  }
-  return result
-}

package/src/rules/__tests__/dedent/removeEmptyPrefix.ts

@@ -1,6 +0,0 @@
-export function removeEmptyPrefix(lines: string[]): string[] {
-  const copy = [...lines]
-  while (copy.length > 0 && copy[0].trim() === '')
-    copy.shift()
-  return copy
-}

package/src/rules/__tests__/dedent/removeEmptySuffix.ts

@@ -1,6 +0,0 @@
-export function removeEmptySuffix(lines: string[]): string[] {
-  const copy = [...lines]
-  while (copy.length > 0 && copy[copy.length - 1].trim() === '')
-    copy.pop()
-  return copy
-}

package/src/rules/__tests__/dedent/removeIndent.ts

@@ -1,3 +0,0 @@
-export function removeIndent(lines: string[], indentSize: number): string {
-  return lines.map(line => line.slice(indentSize)).join('\n')
-}

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

@@ -1,88 +0,0 @@
-import typescript from 'typescript-eslint'
-import {dedent} from './dedent'
-import {importsAndReExportsAtTop} from '../importsAndReExportsAtTop'
-import {RuleTester} from 'eslint'
-import type {Rule} from 'eslint'
-
-const rule = importsAndReExportsAtTop as unknown as Rule.RuleModule
-const ruleTester = new RuleTester({
-  languageOptions: {
-    parser: typescript.parser,
-    parserOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  },
-})
-
-ruleTester.run('imports-and-re-exports-at-top', rule, {
-  valid: [{
-    code: dedent`
-      import {a} from 'aaa'
-      export {a} from 'aaa'
-      const c = 1
-    `,
-  }, {
-    code: dedent`
-      import {a} from 'aaa'
-      import {b} from 'bbb'
-      export {c} from 'ccc'
-    `,
-  }, {
-    code: dedent`
-      import {a} from 'aaa'
-      const c = 1
-      function foo() {}
-    `,
-  }, {
-    code: dedent`
-      export {a} from 'aaa'
-      export * from 'bbb'
-      const c = 1
-    `,
-  }, {
-    code: dedent`
-      const c = 1
-      function foo() {}
-    `,
-  }, {
-    code: dedent`
-      import {a} from 'aaa'
-    `,
-  }, {
-    code: dedent`
-      export {a} from 'aaa'
-    `,
-  }, {
-    code: '',
-  }],
-  invalid: [{
-    code: dedent`
-      export {z} from 'zzz'
-      const c = 1
-      import {a} from 'aaa'
-      function foo() {}
-      export {b} from 'bbb'
-    `,
-    errors: [{messageId: 'importsAndReExportsAtTop'}],
-    output: dedent`
-      import {a} from 'aaa'
-      export {z} from 'zzz'
-      export {b} from 'bbb'
-      const c = 1
-      function foo() {}
-    `,
-  }, {
-    code: dedent`
-      const a = 1
-      import {b} from 'bbb'
-      export {c} from 'ccc'
-    `,
-    errors: [{messageId: 'importsAndReExportsAtTop'}],
-    output: dedent`
-      import {b} from 'bbb'
-      export {c} from 'ccc'
-      const a = 1
-    `,
-  }],
-})

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

@@ -1,44 +0,0 @@
-import typescript from 'typescript-eslint'
-import {dedent} from './dedent'
-import {individualImports} from '../individualImports'
-import {RuleTester} from 'eslint'
-import type {Rule} from 'eslint'
-
-const rule = individualImports as unknown as Rule.RuleModule
-const ruleTester = new RuleTester({
-  languageOptions: {
-    parser: typescript.parser,
-    parserOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  },
-})
-
-ruleTester.run('individual-imports', rule, {
-  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__/individualReExports.test.ts

@@ -1,64 +0,0 @@
-import typescript from 'typescript-eslint'
-import {dedent} from './dedent'
-import {individualReExports} from '../individualReExports'
-import {RuleTester} from 'eslint'
-import type {Rule} from 'eslint'
-
-const rule = individualReExports as unknown as Rule.RuleModule
-const ruleTester = new RuleTester({
-  languageOptions: {
-    parser: typescript.parser,
-    parserOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  },
-})
-
-ruleTester.run('individual-re-exports', rule, {
-  valid: [{
-    code: "export {foo} from 'bar'",
-  }, {
-    code: "export {foo as bar} from 'baz'",
-  }, {
-    code: "export * from 'bar'",
-  }, {
-    code: "export default 'bar'",
-  }, {
-    code: 'export const foo = 1',
-  }, {
-    code: 'export function foo() {}',
-  }, {
-    code: 'export class Foo {}',
-  }],
-  invalid: [{
-    code: "export type {foo, bar} from 'baz'",
-    errors: [{messageId: 'individualReExports'}],
-    output: dedent`
-      export type {foo} from 'baz'
-      export type {bar} from 'baz'
-    `,
-  }, {
-    code: "export {foo, bar} from 'baz'",
-    errors: [{messageId: 'individualReExports'}],
-    output: dedent`
-      export {foo} from 'baz'
-      export {bar} from 'baz'
-    `,
-  }, {
-    code: "export {foo, bar, baz} from 'qux'",
-    errors: [{messageId: 'individualReExports'}],
-    output: dedent`
-      export {foo} from 'qux'
-      export {bar} from 'qux'
-      export {baz} from 'qux'
-    `,
-  }, {
-    code: "export {foo as bar, baz as qux} from 'qux'",
-    errors: [{messageId: 'individualReExports'}],
-    output: dedent`
-      export {foo as bar} from 'qux'
-      export {baz as qux} from 'qux'
-    `,
-  }],
-})

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

@@ -1,75 +0,0 @@
-import typescript from 'typescript-eslint'
-import {dedent} from './dedent'
-import {multilineUnionTypes} from '../multilineUnionTypes'
-import {RuleTester} from 'eslint'
-import type {Rule} from 'eslint'
-
-const rule = multilineUnionTypes as unknown as Rule.RuleModule
-const ruleTester = new RuleTester({
-  languageOptions: {
-    parser: typescript.parser,
-    parserOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  },
-})
-
-ruleTester.run('multiline-union-types', rule, {
-  valid: [{
-    code: 'type A = B',
-  }, {
-    code: dedent`
-      type A = 
-        | B
-        | C
-    `,
-  }, {
-    code: dedent`
-      export type A = 
-        | B
-        | C
-        | D
-    `,
-  }],
-  invalid: [{
-    code: 'type A = B | C | D',
-    errors: [{messageId: 'singleLine'}],
-    output: dedent`
-      type A = 
-        | B
-        | C
-        | D
-    `,
-  }, {
-    code: dedent`
-      type A = B | 
-        C | 
-        D
-    `,
-    errors: [{messageId: 'missingPipes'}],
-    output: dedent`
-      type A = 
-        | B
-        | C
-        | D
-    `,
-  }, {
-    code: 'type A = string | number | boolean',
-    errors: [{messageId: 'singleLine'}],
-    output: dedent`
-      type A = 
-        | string
-        | number
-        | boolean
-    `,
-  }, {
-    code: 'export type Foo = Bar | Baz',
-    errors: [{messageId: 'singleLine'}],
-    output: dedent`
-      export type Foo = 
-        | Bar
-        | Baz
-    `,
-  }],
-})

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

@@ -1,129 +0,0 @@
-import typescript from 'typescript-eslint'
-import {dedent} from './dedent'
-import {RuleTester} from 'eslint'
-import {singleLineImports} from '../singleLineImports'
-import type {Rule} from 'eslint'
-
-const rule = singleLineImports as unknown as Rule.RuleModule
-const ruleTester = new RuleTester({
-  languageOptions: {
-    parser: typescript.parser,
-    parserOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  },
-})
-
-ruleTester.run('single-line-imports', rule, {
-  valid: [{
-    code: "import {foo} from 'bar'",
-  }, {
-    code: "import foo from 'bar'",
-  }, {
-    code: "import * as foo from 'bar'",
-  }, {
-    code: "import 'bar'",
-  }, {
-    code: "import type {Foo} from 'bar'",
-  }, {
-    code: "import foo, {bar} from 'baz'",
-  }, {
-    code: "import {a, b, c} from 'bar'",
-  }, {
-    code: "import {foo} from 'bar' with {type: 'json'}",
-  }, {
-    code: "import type {Foo} from 'bar' with {type: 'json'}",
-  }],
-  invalid: [{
-    code: dedent`
-      import {
-        foo,
-      } from 'bar'
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import {foo} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      import type {
-        Foo,
-      } from 'bar'
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import type {Foo} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      import {
-        a,
-        b,
-        c,
-      } from 'bar'
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import {a, b, c} from 'bar'
-    `,
-  }, {
-    code: dedent`
-      import foo, {
-        bar,
-      } from 'baz'
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import foo, {bar} from 'baz'
-    `,
-  }, {
-    code: dedent`
-      import
-        foo
-        from 'bar'
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import foo from 'bar'
-    `,
-  }, {
-    code: dedent`
-      import * as foo
-        from 'bar'
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import * as foo from 'bar'
-    `,
-  }, {
-    code: dedent`
-      import
-        'bar'
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import 'bar'
-    `,
-  }, {
-    code: dedent`
-      import {
-        foo,
-      } from 'bar' with {type: 'json'}
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import {foo} from 'bar' with {type: 'json'}
-    `,
-  }, {
-    code: dedent`
-      import type {
-        Foo,
-      } from 'bar' with {type: 'json'}
-    `,
-    errors: [{messageId: 'multiline'}],
-    output: dedent`
-      import type {Foo} from 'bar' with {type: 'json'}
-    `,
-  }],
-})