Fix unicorn/switch-case-braces lint issues

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
+    }
   }
 }
 

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`
+    }
   }
 }
 

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/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}`
+    }
   }
 }
 /**

lib/rules/no-boolean-default.js

@@ -97,21 +97,23 @@ module.exports = {
      */
     function verifyDefaultExpression(defaultNode) {
       switch (booleanType) {
-        case 'no-default':
+        case 'no-default': {
           context.report({
             node: defaultNode,
             messageId: 'noBooleanDefault'
           })
           break
+        }
 
-        case 'default-false':
+        case 'default-false': {
           if (defaultNode.type !== 'Literal' || defaultNode.value !== false) {
             context.report({
               node: defaultNode,
               messageId: 'defaultFalse'
             })
           }
           break
+        }
       }
     }
     return utils.compositingVisitors(

lib/rules/require-prop-comment.js

@@ -76,18 +76,22 @@ module.exports = {
         let messageId
 
         switch (type) {
-          case 'block':
+          case 'block': {
             messageId = verifyBlock(lastPrecedingComment)
             break
-          case 'line':
+          }
+          case 'line': {
             messageId = verifyLine(lastPrecedingComment)
             break
-          case 'any':
+          }
+          case 'any': {
             messageId = verifyAny(lastPrecedingComment)
             break
-          default:
+          }
+          default: {
             messageId = verifyJSDoc(lastPrecedingComment)
             break
+          }
         }
 
         if (!messageId) {

lib/rules/v-on-handler-style.js

@@ -179,11 +179,13 @@ module.exports = {
      */
     function verifyForInlineHandler(node, kind) {
       switch (kind) {
-        case 'method':
+        case 'method': {
           return verifyCanUseMethodHandlerForInlineHandler(node)
-        case 'inline-function':
+        }
+        case 'inline-function': {
           reportCanUseInlineFunctionForInlineHandler(node)
           return true
+        }
       }
       return false
     }
@@ -196,7 +198,7 @@ module.exports = {
     function reportForMethodHandler(node, kind) {
       switch (kind) {
         case 'inline':
-        case 'inline-function':
+        case 'inline-function': {
           context.report({
             node,
             messageId:
@@ -205,6 +207,7 @@ module.exports = {
                 : 'preferInlineFunctionOverMethod'
           })
           return true
+        }
       }
       // This path is currently not taken.
       return false
@@ -217,11 +220,13 @@ module.exports = {
      */
     function verifyForInlineFunction(node, kind) {
       switch (kind) {
-        case 'method':
+        case 'method': {
           return verifyCanUseMethodHandlerForInlineFunction(node)
-        case 'inline':
+        }
+        case 'inline': {
           reportCanUseInlineHandlerForInlineFunction(node)
           return true
+        }
       }
       return false
     }
@@ -529,8 +534,9 @@ module.exports = {
               }
               break
             }
-            default:
+            default: {
               return
+            }
           }
         },
         ...(allows.includes('inline-function')