Enable more eslint-plugin-unicorn rules (#2253)

eslint-internal-rules/no-invalid-meta-docs-categories.js

@@ -70,16 +70,16 @@ function checkMetaValidity(context, exportsNode) {
         ) {
           // fixes.push(fixer.insertTextBefore(category.value, '['), fixer.insertTextAfter(category.value, ']'))
 
-          // for vue3 migration
-          if (category.value.value !== 'base') {
+          if (category.value.value === 'base') {
+            fixes.push(fixer.insertTextBefore(category.value, '['))
+          } else {
+            // for vue3 migration
             fixes.push(
               fixer.insertTextBefore(
                 category.value,
                 `['vue3-${category.value.value}', `
               )
             )
-          } else {
-            fixes.push(fixer.insertTextBefore(category.value, '['))
           }
           fixes.push(fixer.insertTextAfter(category.value, ']'))
         }

eslint.config.js

@@ -167,17 +167,14 @@ module.exports = [
       'unicorn/filename-case': 'off',
       'unicorn/no-null': 'off',
       'unicorn/no-array-callback-reference': 'off', // doesn't work well with TypeScript's custom type guards
-      'unicorn/no-negated-condition': 'off', // remove when there are few pull requests (ref: #2146)
       'unicorn/no-useless-undefined': 'off',
       'unicorn/prefer-optional-catch-binding': 'off', // not supported by current ESLint parser version
       'unicorn/prefer-module': 'off',
       'unicorn/prevent-abbreviations': 'off',
       'unicorn/prefer-at': 'off', //                 turn off to prevent make breaking changes (ref: #2146)
       'unicorn/prefer-node-protocol': 'off', //      turn off to prevent make breaking changes (ref: #2146)
       'unicorn/prefer-string-replace-all': 'off', // turn off to prevent make breaking changes (ref: #2146)
-      'unicorn/prefer-ternary': 'off', //            remove when there are few pull requests (ref: #2146)
       'unicorn/prefer-top-level-await': 'off', //    turn off to prevent make breaking changes (ref: #2146)
-      'unicorn/switch-case-braces': 'off', //        remove when there are few pull requests (ref: #2146)
 
       'internal/require-eslint-community': ['error']
     }

lib/processor.js

@@ -46,40 +46,50 @@ module.exports = {
         const directiveType = message.messageId
         const data = message.message.split(' ')
         switch (directiveType) {
-          case 'disableBlock':
+          case 'disableBlock': {
             state.block.disableAllKeys.add(data[1])
             break
-          case 'disableLine':
+          }
+          case 'disableLine': {
             state.line.disableAllKeys.add(data[1])
             break
-          case 'enableBlock':
+          }
+          case 'enableBlock': {
             state.block.disableAllKeys.clear()
             break
-          case 'enableLine':
+          }
+          case 'enableLine': {
             state.line.disableAllKeys.clear()
             break
-          case 'disableBlockRule':
+          }
+          case 'disableBlockRule': {
             addDisableRule(state.block.disableRuleKeys, data[1], data[2])
             break
-          case 'disableLineRule':
+          }
+          case 'disableLineRule': {
             addDisableRule(state.line.disableRuleKeys, data[1], data[2])
             break
-          case 'enableBlockRule':
+          }
+          case 'enableBlockRule': {
             state.block.disableRuleKeys.delete(data[1])
             break
-          case 'enableLineRule':
+          }
+          case 'enableLineRule': {
             state.line.disableRuleKeys.delete(data[1])
             break
-          case 'clear':
+          }
+          case 'clear': {
             state.block.disableAllKeys.clear()
             state.block.disableRuleKeys.clear()
             state.line.disableAllKeys.clear()
             state.line.disableRuleKeys.clear()
             break
-          default:
+          }
+          default: {
             // unused eslint-disable comments report
             unusedDisableDirectiveReports.set(messageToKey(message), message)
             break
+          }
         }
         return false
       } else {

lib/rules/attributes-order.js

@@ -120,30 +120,39 @@ function getAttributeType(attribute) {
     if (!isVBind(attribute)) {
       const name = attribute.key.name.name
       switch (name) {
-        case 'for':
+        case 'for': {
           return ATTRS.LIST_RENDERING
+        }
         case 'if':
         case 'else-if':
         case 'else':
         case 'show':
-        case 'cloak':
+        case 'cloak': {
           return ATTRS.CONDITIONALS
+        }
         case 'pre':
-        case 'once':
+        case 'once': {
           return ATTRS.RENDER_MODIFIERS
-        case 'model':
+        }
+        case 'model': {
           return ATTRS.TWO_WAY_BINDING
-        case 'on':
+        }
+        case 'on': {
           return ATTRS.EVENTS
+        }
         case 'html':
-        case 'text':
+        case 'text': {
           return ATTRS.CONTENT
-        case 'slot':
+        }
+        case 'slot': {
           return ATTRS.SLOT
-        case 'is':
+        }
+        case 'is': {
           return ATTRS.DEFINITION
-        default:
+        }
+        default: {
           return ATTRS.OTHER_DIRECTIVES
+        }
       }
     }
     propName =
@@ -154,24 +163,29 @@ function getAttributeType(attribute) {
     propName = attribute.key.name
   }
   switch (propName) {
-    case 'is':
+    case 'is': {
       return ATTRS.DEFINITION
-    case 'id':
+    }
+    case 'id': {
       return ATTRS.GLOBAL
+    }
     case 'ref':
-    case 'key':
+    case 'key': {
       return ATTRS.UNIQUE
+    }
     case 'slot':
-    case 'slot-scope':
+    case 'slot-scope': {
       return ATTRS.SLOT
-    default:
+    }
+    default: {
       if (isVBind(attribute)) {
         return ATTRS.ATTR_DYNAMIC
       }
       if (isVShorthandBoolean(attribute)) {
         return ATTRS.ATTR_SHORTHAND_BOOL
       }
       return ATTRS.ATTR_STATIC
+    }
   }
 }
 
@@ -182,9 +196,9 @@ function getAttributeType(attribute) {
  */
 function getPosition(attribute, attributePosition) {
   const attributeType = getAttributeType(attribute)
-  return attributePosition[attributeType] != null
-    ? attributePosition[attributeType]
-    : null
+  return attributePosition[attributeType] == null
+    ? null
+    : attributePosition[attributeType]
 }
 
 /**

lib/rules/block-lang.js

@@ -42,10 +42,12 @@ const DEFAULT_LANGUAGES = {
 function getAllowsLangPhrase(lang) {
   const langs = [...lang].map((s) => `"${s}"`)
   switch (langs.length) {
-    case 1:
+    case 1: {
       return langs[0]
-    default:
+    }
+    default: {
       return `${langs.slice(0, -1).join(', ')}, and ${langs[langs.length - 1]}`
+    }
   }
 }
 

lib/rules/block-tag-newline.js

@@ -25,10 +25,12 @@ function getLinebreakCount(text) {
  */
 function getPhrase(lineBreaks) {
   switch (lineBreaks) {
-    case 1:
+    case 1: {
       return '1 line break'
-    default:
+    }
+    default: {
       return `${lineBreaks} line breaks`
+    }
   }
 }
 
@@ -322,17 +324,17 @@ module.exports = {
       return (element) => {
         const { name } = element
         const elementsOptions = blocks[name]
-        if (!elementsOptions) {
-          verifyElement(element, options)
-        } else {
+        if (elementsOptions) {
           normalizeOptionValue({
             singleline: elementsOptions.singleline || options.singleline,
             multiline: elementsOptions.multiline || options.multiline,
             maxEmptyLines:
-              elementsOptions.maxEmptyLines != null
-                ? elementsOptions.maxEmptyLines
-                : options.maxEmptyLines
+              elementsOptions.maxEmptyLines == null
+                ? options.maxEmptyLines
+                : elementsOptions.maxEmptyLines
           })(element)
+        } else {
+          verifyElement(element, options)
         }
       }
     }

lib/rules/comment-directive.js

@@ -70,16 +70,16 @@ function parse(pattern, comment) {
  * @returns {void}
  */
 function enable(context, loc, group, rule) {
-  if (!rule) {
+  if (rule) {
     context.report({
       loc,
-      messageId: group === 'block' ? 'enableBlock' : 'enableLine'
+      messageId: group === 'block' ? 'enableBlockRule' : 'enableLineRule',
+      data: { rule }
     })
   } else {
     context.report({
       loc,
-      messageId: group === 'block' ? 'enableBlockRule' : 'enableLineRule',
-      data: { rule }
+      messageId: group === 'block' ? 'enableBlock' : 'enableLine'
     })
   }
 }
@@ -94,17 +94,17 @@ function enable(context, loc, group, rule) {
  * @returns {void}
  */
 function disable(context, loc, group, rule, key) {
-  if (!rule) {
+  if (rule) {
     context.report({
       loc,
-      messageId: group === 'block' ? 'disableBlock' : 'disableLine',
-      data: { key }
+      messageId: group === 'block' ? 'disableBlockRule' : 'disableLineRule',
+      data: { rule, key }
     })
   } else {
     context.report({
       loc,
-      messageId: group === 'block' ? 'disableBlockRule' : 'disableLineRule',
-      data: { rule, key }
+      messageId: group === 'block' ? 'disableBlock' : 'disableLine',
+      data: { key }
     })
   }
 }

lib/rules/define-emits-declaration.js

@@ -36,23 +36,25 @@ module.exports = {
     return utils.defineScriptSetupVisitor(context, {
       onDefineEmitsEnter(node) {
         switch (defineType) {
-          case 'type-based':
+          case 'type-based': {
             if (node.arguments.length > 0) {
               context.report({
                 node,
                 messageId: 'hasArg'
               })
             }
             break
+          }
 
-          case 'runtime':
+          case 'runtime': {
             if (node.typeParameters && node.typeParameters.params.length > 0) {
               context.report({
                 node,
                 messageId: 'hasTypeArg'
               })
             }
             break
+          }
         }
       }
     })

lib/rules/define-props-declaration.js

@@ -36,23 +36,25 @@ module.exports = {
     return utils.defineScriptSetupVisitor(context, {
       onDefinePropsEnter(node) {
         switch (defineType) {
-          case 'type-based':
+          case 'type-based': {
             if (node.arguments.length > 0) {
               context.report({
                 node,
                 messageId: 'hasArg'
               })
             }
             break
+          }
 
-          case 'runtime':
+          case 'runtime': {
             if (node.typeParameters && node.typeParameters.params.length > 0) {
               context.report({
                 node,
                 messageId: 'hasTypeArg'
               })
             }
             break
+          }
         }
       }
     })

lib/rules/html-closing-bracket-newline.js

@@ -12,12 +12,15 @@ const utils = require('../utils')
  */
 function getPhrase(lineBreaks) {
   switch (lineBreaks) {
-    case 0:
+    case 0: {
       return 'no line breaks'
-    case 1:
+    }
+    case 1: {
       return '1 line break'
-    default:
+    }
+    default: {
       return `${lineBreaks} line breaks`
+    }
   }
 }
 

lib/rules/html-self-closing.js

@@ -78,7 +78,7 @@ function getElementType(node) {
  */
 function isEmpty(node, sourceCode) {
   const start = node.startTag.range[1]
-  const end = node.endTag != null ? node.endTag.range[0] : node.range[1]
+  const end = node.endTag == null ? node.range[1] : node.endTag.range[0]
 
   return sourceCode.text.slice(start, end).trim() === ''
 }

lib/rules/multiline-html-element-content-newline.js

@@ -34,10 +34,12 @@ function parseOptions(options) {
  */
 function getPhrase(lineBreaks) {
   switch (lineBreaks) {
-    case 0:
+    case 0: {
       return 'no'
-    default:
+    }
+    default: {
       return `${lineBreaks}`
+    }
   }
 }
 /**