@tuomashatakka/eslint-config 2.6.2 → 3.1.0

package/index.mjs

@@ -1,14 +1,13 @@
 import stylistic from '@stylistic/eslint-plugin'
-import stylisticJsx from '@stylistic/eslint-plugin-jsx'
-import tsplugin from '@typescript-eslint/eslint-plugin'
 import importPlugin from 'eslint-plugin-import'
-import noInlineMultilineTypesPlugin from 'eslint-plugin-no-inline-multiline-types'
-import whitespacedPlugin from 'eslint-plugin-whitespaced'
-import omitPlugin from 'eslint-plugin-omit-unnecessary'
+import noInlineMultilineTypesPlugin from './plugins/no-inline-types/index.mjs'
+import whitespacedPlugin from './plugins/whitespaced/index.mjs'
+import omitPlugin from './plugins/omit/index.mjs'
 import react from 'eslint-plugin-react'
 import reactHooks from 'eslint-plugin-react-hooks'
 import globals from 'globals'
 import tseslint from 'typescript-eslint'
+import reactStrictPlugin from './plugins/react-strict/index.mjs'
 import { rules } from './rules.mjs'
 
 
@@ -17,10 +16,11 @@ const plugins = {
   'react-hooks':        reactHooks,
   'import':             importPlugin,
   '@stylistic':         stylistic,
-  '@typescript-eslint': tsplugin,
+  '@typescript-eslint': tseslint.plugin,
   'omit':               omitPlugin,
   'no-inline-types':    noInlineMultilineTypesPlugin,
   'whitespaced':        whitespacedPlugin,
+  'react-strict':       reactStrictPlugin,
 }
 
 export { rules }
@@ -38,17 +38,7 @@ export const baseConfig = {
     'import/internal-regex': '^@/(.+)',
   },
   ignores: [ '**/node_modules/**' ],
-  plugins: {
-    ...plugins,
-    // Merge stylistic JSX plugin into the main stylistic namespace
-    '@stylistic': {
-      ...stylistic,
-      rules: {
-        ...stylistic.rules,
-        ...stylisticJsx.rules,
-      }
-    }
-  },
+  plugins,
   rules,
 }
 
@@ -60,9 +50,5 @@ export const config = tseslint.config(
   ...tseslint.configs.recommended,
   baseConfig)
 
-/**
- * @summary ESLint configuration
- * @description Opinionated yet functional AF base config for ESLint
- */
 
 export default config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tuomashatakka/eslint-config",
-  "version": "2.6.2",
+  "version": "3.1.0",
   "description": "Default eslint configuration",
   "type": "module",
   "main": "index.mjs",
@@ -26,28 +26,20 @@
     "typescript": "*"
   },
   "dependencies": {
-    "eslint": "^9.31.0",
-    "@stylistic/eslint-plugin": "^5.2.0",
-    "@stylistic/eslint-plugin-jsx": "^2.13.0",
-    "typescript-eslint": "^8.37.0",
-    "globals": "^16.3.0",
-    "typescript": "^5.8.3",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/react": "^19.2.14",
+    "eslint": "^9.39.0",
+    "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
-    "eslint-plugin-import": "^2.32.0",
-    "@typescript-eslint/eslint-plugin": "^8.37.0",
-    "eslint-plugin-no-inline-multiline-types": "^0.0.5",
-    "eslint-plugin-omit-unnecessary": "^0.0.3",
-    "eslint-plugin-whitespaced": "^1.0.2"
+    "globals": "^16.5.0",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.58.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.3.1",
-    "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.31.0",
-    "@stylistic/eslint-plugin-ts": "^4.4.1",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^9.39.0",
     "@types/eslint__eslintrc": "^2.1.2",
-    "@types/eslint__js": "^8.42.3",
-    "@typescript-eslint/parser": "^8.37.0",
-    "eslint-plugin-block-padding": "^0.0.3"
+    "@types/eslint__js": "^8.42.3"
   }
 }

package/plugins/no-inline-types/index.mjs

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Disallows inline type definitions that span multiple lines.
+ */
+import noInline from './rules/no-inline-multiline-types.mjs'
+
+
+export default {
+  rules: {
+    'no-inline-multiline-types': noInline,
+  },
+}

package/plugins/no-inline-types/rules/no-inline-multiline-types.mjs

@@ -0,0 +1,181 @@
+/**
+ * @fileoverview Disallows inline TSTypeLiteral annotations that span multiple lines.
+ */
+
+function toPascalCase (str) {
+  if (!str)
+    return ''
+  str = str.replace(/_([a-z])/g, (match, char) => char.toUpperCase())
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+
+/** @type {import('eslint').Rule.RuleModule} */
+const rule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallows inline TSTypeLiteral annotations',
+      recommended: false,
+      url:         null,
+    },
+    fixable:  "code",
+    schema:   [],
+    messages: {
+      inlineType: 'Inline type literal annotations are disallowed. Extract to a named interface or type alias.',
+    },
+  },
+
+  create (context) {
+    const sourceCode = context.getSourceCode()
+
+
+    function findInsertionPointAncestor (startNode) {
+      let currentNode = startNode
+      const targetAncestorTypes = new Set([
+        'VariableDeclaration',
+        'FunctionDeclaration',
+        'ClassDeclaration',
+        'TSInterfaceDeclaration',
+        'TSTypeAliasDeclaration',
+      ])
+      const validParentContextTypes = new Set([
+        'Program',
+        'BlockStatement',
+        'ExportNamedDeclaration',
+        'ExportDefaultDeclaration',
+      ])
+
+      while (currentNode.parent) {
+        if (targetAncestorTypes.has(currentNode.type) && currentNode.parent && validParentContextTypes.has(currentNode.parent.type)) {
+          if (currentNode.parent.type === 'ExportNamedDeclaration' || currentNode.parent.type === 'ExportDefaultDeclaration')
+            return currentNode.parent
+          return currentNode
+        }
+        if ((currentNode.type === 'ExportNamedDeclaration' || currentNode.type === 'ExportDefaultDeclaration') &&
+            currentNode.declaration && targetAncestorTypes.has(currentNode.declaration.type))
+          return currentNode
+
+        currentNode = currentNode.parent
+        if (currentNode.type === 'Program') {
+          if (targetAncestorTypes.has(startNode.type))
+            return startNode
+          break
+        }
+      }
+      return null
+    }
+
+
+    function deriveTypeName (typeAnnotationNode) {
+      const parent = typeAnnotationNode.parent
+      if (!parent)
+        return 'ExtractedType'
+
+      try {
+        if (parent.type === 'Identifier' && parent.parent && parent.parent.type === 'VariableDeclarator')
+          return toPascalCase(parent.name) + 'Type'
+
+        if (parent.type === 'Identifier' && parent.parent && (
+          parent.parent.type === 'FunctionDeclaration' ||
+          parent.parent.type === 'FunctionExpression' ||
+          parent.parent.type === 'ArrowFunctionExpression' ||
+          parent.parent.type === 'TSParameterProperty'
+        )) {
+          if (parent.parent.params && parent.parent.params.includes(parent))
+            return toPascalCase(parent.name) + 'Type'
+          if (parent.parent.type === 'TSParameterProperty' && parent.parent.parameter === parent)
+            return toPascalCase(parent.name) + 'Type'
+        }
+
+        if (parent.type === 'ObjectPattern' && parent.parent && (
+          parent.parent.type === 'FunctionDeclaration' ||
+          parent.parent.type === 'FunctionExpression' ||
+          parent.parent.type === 'ArrowFunctionExpression'
+        )) {
+          const funcName = parent.parent.id?.name
+          return funcName ? toPascalCase(funcName) + 'Props' : 'PropsType'
+        }
+
+        if (parent.type === 'ArrayPattern' && parent.parent && (
+          parent.parent.type === 'FunctionDeclaration' ||
+          parent.parent.type === 'FunctionExpression' ||
+          parent.parent.type === 'ArrowFunctionExpression'
+        ))
+          return 'ParamsType'
+
+        if (parent.type === 'PropertyDefinition' && parent.key && parent.key.type === 'Identifier')
+          return toPascalCase(parent.key.name) + 'Type'
+
+        if ((parent.type === 'FunctionDeclaration' || parent.type === 'FunctionExpression' || parent.type === 'ArrowFunctionExpression') &&
+            parent.returnType === typeAnnotationNode) {
+          const funcName = parent.id?.name
+          if (!funcName && parent.parent && parent.parent.type === 'VariableDeclarator' && parent.parent.id.type === 'Identifier')
+            return toPascalCase(parent.parent.id.name) + 'ReturnType'
+          return toPascalCase(funcName || 'Function') + 'ReturnType'
+        }
+
+        if (parent.type === 'TSParameterProperty' && parent.parameter && parent.parameter.type === 'Identifier')
+          return toPascalCase(parent.parameter.name) + 'Type'
+      }
+      catch (e) {
+        console.error('Error deriving type name:', e)
+      }
+
+      return 'ExtractedType'
+    }
+
+
+    function checkMultilineLiteralInAnnotation (typeAnnotationNode) {
+      if (!typeAnnotationNode || typeAnnotationNode.type !== 'TSTypeAnnotation')
+        return
+
+      const literalNode = typeAnnotationNode.typeAnnotation
+
+      if (literalNode && literalNode.type === 'TSTypeLiteral')
+        context.report({
+          node:      literalNode,
+          messageId: 'inlineType',
+          fix (fixer) {
+            const newTypeName        = deriveTypeName(typeAnnotationNode)
+            const literalText        = sourceCode.getText(literalNode)
+            const typeAliasString    = `type ${newTypeName} = ${literalText};\n\n`
+            const insertionAncestor  = findInsertionPointAncestor(typeAnnotationNode)
+
+            if (!insertionAncestor)
+              return null
+
+            return [
+              fixer.insertTextBefore(insertionAncestor, typeAliasString),
+              fixer.replaceText(literalNode, newTypeName),
+            ]
+          },
+        })
+    }
+
+
+    return {
+      VariableDeclarator (node) {
+        if (node.id && node.id.typeAnnotation)
+          checkMultilineLiteralInAnnotation(node.id.typeAnnotation)
+      },
+      PropertyDefinition (node) {
+        if (node.typeAnnotation)
+          checkMultilineLiteralInAnnotation(node.typeAnnotation)
+      },
+      ':function' (node) {
+        if (node.returnType)
+          checkMultilineLiteralInAnnotation(node.returnType)
+        if (node.params)
+          for (const param of node.params)
+            if (param && param.typeAnnotation)
+              checkMultilineLiteralInAnnotation(param.typeAnnotation)
+            else if (param.type === 'TSParameterProperty' && param.parameter && param.parameter.typeAnnotation)
+              checkMultilineLiteralInAnnotation(param.parameter.typeAnnotation)
+      },
+    }
+  },
+}
+
+
+export default rule

package/plugins/omit/index.mjs

@@ -0,0 +1,8 @@
+import omit from './rules/omit-unnecessary-parens-brackets.mjs'
+
+
+export default {
+  rules: {
+    'omit-unnecessary-parens-brackets': omit,
+  },
+}

package/plugins/omit/rules/omit-unnecessary-parens-brackets.mjs

@@ -0,0 +1,329 @@
+/**
+ * @fileoverview Rule to omit unnecessary parentheses, brackets, and braces
+ */
+
+import { isValidDotNotationIdentifier, isDeclaration, isParenthesized } from '../utils.mjs'
+
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Omit unnecessary parentheses, brackets, and braces',
+      category:    "Stylistic Issues",
+      recommended: false,
+      url:         null,
+    },
+    fixable:  "code",
+    schema:   [],
+    messages: {
+      unnecessaryParens:   "Unnecessary parentheses",
+      useDotNotation:      "Use dot notation instead of bracket notation",
+      unnecessaryBraces:   "Unnecessary curly braces",
+    }
+  },
+  create (context) {
+    const sourceCode = context.getSourceCode()
+
+
+function checkDotNotation (node) {
+      if (node.computed &&
+        node.property.type === 'Literal' &&
+        typeof node.property.value === 'string' &&
+        isValidDotNotationIdentifier(node.property.value) &&
+        !node.optional
+      ) context.report({
+          node: node.property,
+          messageId: "useDotNotation",
+          fix(fixer) {
+            const propText      = node.property.value
+            const openingBracket = sourceCode.getTokenBefore(node.property)
+            const closingBracket = sourceCode.getTokenAfter(node.property)
+
+            if (!openingBracket || openingBracket.value !== '[' || !closingBracket || closingBracket.value !== ']')
+              return null
+
+            const textBetweenObjectAndBracket   = sourceCode.text.slice(node.object.range[1], openingBracket.range[0])
+            const textBetweenPropertyAndBracket = sourceCode.text.slice(node.property.range[1], closingBracket.range[0])
+
+            if (textBetweenObjectAndBracket.trim() !== '' || textBetweenPropertyAndBracket.trim() !== '')
+              return null
+
+            return fixer.replaceTextRange(
+              [openingBracket.range[0], closingBracket.range[1]],
+              `.${propText}`
+            )
+          }
+        })
+    }
+
+
+function checkUnnecessaryParens (node) {
+      if (!node || !isParenthesized(node, sourceCode))
+        return
+
+      const parent      = node.parent
+      const tokenBefore = sourceCode.getTokenBefore(node)
+      const tokenAfter  = sourceCode.getTokenAfter(node)
+
+      if (!tokenBefore || !tokenAfter)
+        return
+
+      const reportAndFixUnnecessaryParens = reportedNode => {
+        context.report({
+          node:      reportedNode,
+          loc:       { start: tokenBefore.loc.start, end: tokenAfter.loc.end },
+          messageId: 'unnecessaryParens',
+          fix:       (fixer) => [ fixer.remove(tokenBefore), fixer.remove(tokenAfter) ],
+        })
+      }
+
+      if (parent && isParenthesized(parent, sourceCode)) {
+        const parentTokenBefore = sourceCode.getTokenBefore(parent)
+        const parentTokenAfter  = sourceCode.getTokenAfter(parent)
+        if (parentTokenBefore && parentTokenAfter &&
+          parentTokenBefore.range[0] === tokenBefore.range[0] - 1 &&
+          parentTokenAfter.range[1] === tokenAfter.range[1] + 1) {
+          reportAndFixUnnecessaryParens(node)
+          return
+        }
+      }
+
+      if (node.type === 'Literal' || node.type === 'Identifier') {
+        if (parent && (
+          parent.type === 'VariableDeclarator'  && parent.init      === node ||
+          parent.type === 'ReturnStatement'     && parent.argument   === node ||
+          parent.type === 'ExpressionStatement' && parent.expression === node ||
+          parent.type === 'ArrayExpression'     && parent.elements.includes(node) ||
+          parent.type === 'Property'            && parent.value === node && !parent.method && !parent.shorthand
+        )) {
+          reportAndFixUnnecessaryParens(node)
+          return
+        }
+      }
+
+      if (node.type === 'AwaitExpression' || node.type === 'YieldExpression') {
+        if (parent && (
+          parent.type === 'ExpressionStatement' ||
+          parent.type === 'VariableDeclarator' ||
+          parent.type === 'ReturnStatement' ||
+          parent.type === 'AssignmentExpression' && parent.right === node
+        )) {
+          reportAndFixUnnecessaryParens(node)
+          return
+        }
+      }
+
+      if (parent && parent.type === 'ArrowFunctionExpression' && parent.body === node) {
+        if (node.type !== 'ObjectExpression') {
+          reportAndFixUnnecessaryParens(node)
+          return
+        }
+      }
+
+      if (parent && parent.type === 'ReturnStatement' && parent.argument === node &&
+          (node.type === 'JSXElement' || node.type === 'JSXFragment')) {
+        context.report({
+          node,
+          loc:       { start: tokenBefore.loc.start, end: tokenAfter.loc.end },
+          messageId: 'unnecessaryParens',
+          fix:       (fixer) => {
+            const returnToken = sourceCode.getFirstToken(parent)
+            return [
+              fixer.replaceTextRange([ returnToken.range[1], node.range[0] ], ' '),
+              fixer.removeRange([ node.range[1], tokenAfter.range[1] ]),
+            ]
+          },
+        })
+        return
+      }
+    }
+
+
+function checkUnnecessaryBraces (blockStatement, controllingNode) {
+      if (!blockStatement || blockStatement.type !== 'BlockStatement')
+        return
+
+      if (blockStatement.body.length !== 1)
+        return
+
+      const singleStatement = blockStatement.body[0]
+
+      if (isDeclaration(singleStatement))
+        return
+
+      if (controllingNode && controllingNode.type === 'IfStatement' &&
+        !controllingNode.alternate &&
+        singleStatement.type === 'IfStatement')
+        return
+
+      if (singleStatement.type === 'BlockStatement')
+        return
+
+      context.report({
+        node:      blockStatement,
+        messageId: 'unnecessaryBraces',
+        fix (fixer) {
+          const firstToken = sourceCode.getFirstToken(blockStatement)
+          const lastToken  = sourceCode.getLastToken(blockStatement)
+          const innerText  = sourceCode.getText(singleStatement)
+
+          if (!firstToken || firstToken.value !== '{' || !lastToken || lastToken.value !== '}')
+            return null
+
+          const firstStatementToken = sourceCode.getFirstToken(singleStatement)
+          const lastStatementToken  = sourceCode.getLastToken(singleStatement)
+
+          if (firstStatementToken && firstToken.range[1] < firstStatementToken.range[0]) {
+            const tokensBefore = sourceCode.getTokensBetween(firstToken, firstStatementToken, {
+              includeComments: false,
+            })
+            if (tokensBefore.length > 0)
+              return null
+          }
+
+          if (lastStatementToken && lastToken.range[1] < lastStatementToken.range[0]) {
+            const tokensAfter = sourceCode.getTokensBetween(lastStatementToken, lastToken, {
+              includeComments: false,
+            })
+            if (tokensAfter.length > 0)
+              return null
+          }
+
+          return fixer.replaceTextRange(blockStatement.range, innerText)
+        },
+      })
+    }
+
+
+function checkArrowFunctionBraces (node) {
+      if (!node.body || node.body.type !== 'BlockStatement')
+        return
+
+      const blockBody = node.body
+      if (blockBody.body.length !== 1)
+        return
+
+      const singleStatement = blockBody.body[0]
+      if (singleStatement.type !== 'ReturnStatement')
+        return
+
+      if (!singleStatement.argument)
+        return
+
+      const returnedExpression = singleStatement.argument
+      const needsParens        = returnedExpression.type === 'ObjectExpression'
+
+      context.report({
+        node:      blockBody,
+        messageId: 'unnecessaryBraces',
+        fix (fixer) {
+          const arrowToken     = sourceCode.getTokenBefore(blockBody)
+          if (!arrowToken || arrowToken.value !== '=>')
+            return null
+
+          const firstBlockToken = sourceCode.getFirstToken(blockBody)
+          const lastBlockToken  = sourceCode.getLastToken(blockBody)
+          if (!firstBlockToken || firstBlockToken.value !== '{' || !lastBlockToken || lastBlockToken.value !== '}')
+            return null
+
+          let expressionText = sourceCode.getText(returnedExpression)
+
+          const textBeforeBlock  = sourceCode.text.slice(arrowToken.range[1], firstBlockToken.range[0])
+          if (textBeforeBlock.trim())
+            return null
+
+          const returnToken      = sourceCode.getFirstToken(singleStatement)
+          const textBeforeReturn = sourceCode.text.slice(firstBlockToken.range[1], returnToken.range[0])
+          const textAfterReturn  = sourceCode.text.slice(returnToken.range[1], returnedExpression.range[0])
+          const textAfterExpr    = sourceCode.text.slice(returnedExpression.range[1], lastBlockToken.range[0])
+
+          if (textBeforeReturn.trim() || textAfterReturn.trim() || textAfterExpr.trim())
+            return null
+
+          if (needsParens && !isParenthesized(returnedExpression, sourceCode))
+            expressionText = `(${expressionText})`
+
+          let replacementText = (needsParens || expressionText.startsWith('(') ? '' : ' ') + expressionText
+          replacementText = replacementText.replace(/\s+/g, ' ')
+          return fixer.replaceTextRange(blockBody.range, replacementText.trim())
+        },
+      })
+    }
+
+
+return {
+      MemberExpression: checkDotNotation,
+
+      VariableDeclarator (node) {
+ checkUnnecessaryParens(node.init) 
+},
+      ExpressionStatement (node) {
+ checkUnnecessaryParens(node.expression) 
+},
+      ReturnStatement (node) {
+ checkUnnecessaryParens(node.argument) 
+},
+      BinaryExpression (node) {
+ checkUnnecessaryParens(node.left); checkUnnecessaryParens(node.right) 
+},
+      LogicalExpression (node) {
+ checkUnnecessaryParens(node.left); checkUnnecessaryParens(node.right) 
+},
+      UnaryExpression (node) {
+ checkUnnecessaryParens(node.argument) 
+},
+      AwaitExpression (node) {
+ checkUnnecessaryParens(node.argument) 
+},
+      YieldExpression (node) {
+ checkUnnecessaryParens(node.argument) 
+},
+      ConditionalExpression (node) {
+        checkUnnecessaryParens(node.test)
+        checkUnnecessaryParens(node.consequent)
+        checkUnnecessaryParens(node.alternate)
+      },
+      CallExpression (node) {
+        node.arguments.forEach(arg => checkUnnecessaryParens(arg))
+        checkUnnecessaryParens(node.callee)
+      },
+      NewExpression (node) {
+        node.arguments.forEach(arg => checkUnnecessaryParens(arg))
+        checkUnnecessaryParens(node.callee)
+      },
+      ArrayExpression (node) {
+ node.elements.forEach(arg => checkUnnecessaryParens(arg)) 
+},
+      Property (node) {
+ checkUnnecessaryParens(node.value) 
+},
+
+      IfStatement (node) {
+        checkUnnecessaryBraces(node.consequent, node)
+        if (node.alternate && node.alternate.type !== 'IfStatement')
+          checkUnnecessaryBraces(node.alternate, node)
+      },
+      ForStatement (node) {
+ checkUnnecessaryBraces(node.body, node) 
+},
+      ForInStatement (node) {
+ checkUnnecessaryBraces(node.body, node) 
+},
+      ForOfStatement (node) {
+ checkUnnecessaryBraces(node.body, node) 
+},
+      WhileStatement (node) {
+ checkUnnecessaryBraces(node.body, node) 
+},
+      DoWhileStatement (node) {
+ checkUnnecessaryBraces(node.body, node) 
+},
+
+      ArrowFunctionExpression (node) {
+        checkUnnecessaryParens(node.body)
+        checkArrowFunctionBraces(node)
+      },
+    }
+  },
+}