Merge branch 'master' into rewrite-ts

# Conflicts:
#	lib/plugin.js
#	tests/lib/rules/block-order.ts
#	tools/update-lib-plugin.js

Author: 9romise

.changeset/gorgeous-colts-bathe.md

@@ -0,0 +1,5 @@
+---
+"eslint-plugin-vue": patch
+---
+
+Updates resources

.changeset/rich-bags-turn.md

@@ -0,0 +1,5 @@
+---
+"eslint-plugin-vue": minor
+---
+
+Changed `vue/no-negated-v-if-condition` suggestion to autofix

.changeset/rich-zebras-type.md

@@ -1,5 +1,13 @@
 # eslint-plugin-vue
 
+## 10.6.2
+
+### Patch Changes
+
+- Fixed false positives in non-intersecting conditions in [`vue/no-duplicate-class-names`](https://eslint.vuejs.org/rules/no-duplicate-class-names.html) and correctly detect duplicates in combining expressions ([#2980](https://github.com/vuejs/eslint-plugin-vue/pull/2980))
+- Fixed false positives for `TSImportType` in [`vue/script-indent`](https://eslint.vuejs.org/rules/script-indent.html) rule ([#2969](https://github.com/vuejs/eslint-plugin-vue/pull/2969))
+- Improved performance and type safety in [`vue/prefer-use-template-ref`](https://eslint.vuejs.org/rules/prefer-use-template-ref.html) ([#2982](https://github.com/vuejs/eslint-plugin-vue/pull/2982))
+
 ## 10.6.1
 
 ### Patch Changes
@@ -11,15 +19,12 @@
 ### Minor Changes
 
 - Updated [`vue/no-import-compiler-macros`](https://eslint.vuejs.org/rules/no-import-compiler-macros.html) to clarify that macros are not allowed outside `<script setup>` ([#2938](https://github.com/vuejs/eslint-plugin-vue/pull/2938))
-
 - Added new [`vue/no-duplicate-class-names`](https://eslint.vuejs.org/rules/no-duplicate-class-names.html) rule ([#2934](https://github.com/vuejs/eslint-plugin-vue/pull/2934))
 
 ### Patch Changes
 
 - Fixed [`vue/no-v-html`](https://eslint.vuejs.org/rules/no-v-html.html) rule to allow ignoring call expressions ([#2950](https://github.com/vuejs/eslint-plugin-vue/pull/2950))
-
 - Improved [`vue/define-macros-order`](https://eslint.vuejs.org/rules/define-macros-order.html) error messages to distinguish between macro placement and ordering issues ([#2953](https://github.com/vuejs/eslint-plugin-vue/pull/2953))
-
 - Updated dependency [postcss-selector-parser](https://github.com/postcss/postcss-selector-parser) to v7.1.0 ([#2947](https://github.com/vuejs/eslint-plugin-vue/pull/2947))
 
 ## 10.5.1

CHANGELOG.md

@@ -238,7 +238,7 @@ For example:
 | [vue/no-empty-component-block] | disallow the `<template>` `<script>` `<style>` block to be empty | :wrench: | :hammer: |
 | [vue/no-import-compiler-macros] | disallow importing Vue compiler macros | :wrench: | :warning: |
 | [vue/no-multiple-objects-in-class] | disallow passing multiple objects in an array to class |  | :hammer: |
-| [vue/no-negated-v-if-condition] | disallow negated conditions in v-if/v-else | :bulb: | :hammer: |
+| [vue/no-negated-v-if-condition] | disallow negated conditions in v-if/v-else | :wrench: | :hammer: |
 | [vue/no-potential-component-option-typo] | disallow a potential typo in your component property | :bulb: | :hammer: |
 | [vue/no-ref-object-reactivity-loss] | disallow usages of ref objects that can lead to loss of reactivity |  | :warning: |
 | [vue/no-restricted-block] | disallow specific block |  | :hammer: |

docs/rules/index.md

@@ -10,15 +10,15 @@ since: v10.4.0
 
 > disallow negated conditions in v-if/v-else
 
-- :bulb: Some problems reported by this rule are manually fixable by editor [suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).
+- :wrench: The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fix-problems) can automatically fix some of the problems reported by this rule.
 
 ## :book: Rule Details
 
 This rule disallows negated conditions in `v-if` and `v-else-if` directives which have an `v-else` branch.
 
 Negated conditions make the code less readable. When there's an `else` clause, it's better to use a positive condition and switch the branches.
 
-<eslint-code-block :rules="{'vue/no-negated-v-if-condition': ['error']}">
+<eslint-code-block fix :rules="{'vue/no-negated-v-if-condition': ['error']}">
 
 ```vue
 <template>

docs/rules/no-negated-v-if-condition.md

@@ -11,15 +11,21 @@ const utils = require('../utils')
  * @param {VDirective} node
  * @param {Expression} [expression]
  * @param {boolean} [unconditional=true] whether the expression is unconditional
- * @return {IterableIterator<{ node: Literal | TemplateElement, unconditional: boolean }>}
+ * @param {Expression} [parentExpr] parent expression for context
+ * @return {IterableIterator<{ node: Literal | TemplateElement, unconditional: boolean, parentExpr?: Expression }>}
  */
-function* extractClassNodes(node, expression, unconditional = true) {
+function* extractClassNodes(
+  node,
+  expression,
+  unconditional = true,
+  parentExpr
+) {
   const nodeExpression = expression ?? node.value?.expression
   if (!nodeExpression) return
 
   switch (nodeExpression.type) {
     case 'Literal': {
-      yield { node: nodeExpression, unconditional }
+      yield { node: nodeExpression, unconditional, parentExpr }
       break
     }
     case 'ObjectExpression': {
@@ -29,42 +35,76 @@ function* extractClassNodes(node, expression, unconditional = true) {
           prop.key?.type === 'Literal' &&
           typeof prop.key.value === 'string'
         ) {
-          yield { node: prop.key, unconditional: false }
+          yield {
+            node: prop.key,
+            unconditional: false,
+            parentExpr: nodeExpression
+          }
         }
       }
       break
     }
     case 'ArrayExpression': {
       for (const element of nodeExpression.elements) {
         if (!element || element.type === 'SpreadElement') continue
-        yield* extractClassNodes(node, element, unconditional)
+        yield* extractClassNodes(node, element, unconditional, nodeExpression)
       }
       break
     }
     case 'ConditionalExpression': {
-      yield* extractClassNodes(node, nodeExpression.consequent, false)
-      yield* extractClassNodes(node, nodeExpression.alternate, false)
+      yield* extractClassNodes(
+        node,
+        nodeExpression.consequent,
+        false,
+        nodeExpression
+      )
+      yield* extractClassNodes(
+        node,
+        nodeExpression.alternate,
+        false,
+        nodeExpression
+      )
       break
     }
     case 'TemplateLiteral': {
       for (const quasi of nodeExpression.quasis) {
-        yield { node: quasi, unconditional }
+        yield { node: quasi, unconditional, parentExpr: nodeExpression }
       }
       for (const expr of nodeExpression.expressions) {
-        yield* extractClassNodes(node, expr, unconditional)
+        yield* extractClassNodes(node, expr, unconditional, nodeExpression)
       }
       break
     }
     case 'BinaryExpression': {
       if (nodeExpression.operator === '+') {
-        yield* extractClassNodes(node, nodeExpression.left, unconditional)
-        yield* extractClassNodes(node, nodeExpression.right, unconditional)
+        yield* extractClassNodes(
+          node,
+          nodeExpression.left,
+          unconditional,
+          nodeExpression
+        )
+        yield* extractClassNodes(
+          node,
+          nodeExpression.right,
+          unconditional,
+          nodeExpression
+        )
       }
       break
     }
     case 'LogicalExpression': {
-      yield* extractClassNodes(node, nodeExpression.left, unconditional)
-      yield* extractClassNodes(node, nodeExpression.right, unconditional)
+      yield* extractClassNodes(
+        node,
+        nodeExpression.left,
+        unconditional,
+        nodeExpression
+      )
+      yield* extractClassNodes(
+        node,
+        nodeExpression.right,
+        false,
+        nodeExpression
+      )
       break
     }
   }
@@ -250,11 +290,15 @@ module.exports = {
         /** @type {Map<string, ASTNode>} */
         const seen = new Map()
 
-        /** @type {Map<string, {node: ASTNode, unconditional: boolean}>} */
+        /** @type {Map<string, {node: ASTNode, unconditional: boolean, parentExpr?: Expression}>} */
         const collected = new Map()
 
         const classNodes = extractClassNodes(node)
-        for (const { node: reportNode, unconditional } of classNodes) {
+        for (const {
+          node: reportNode,
+          unconditional,
+          parentExpr
+        } of classNodes) {
           // report fixable duplicates and collect reported class names
           const reportedClasses = reportDuplicateClasses(reportNode)
           if (reportedClasses) {
@@ -272,14 +316,21 @@ module.exports = {
             if (reported.has(className)) continue
             const existing = collected.get(className)
             if (existing) {
-              // only add duplicate if at least one is unconditional
-              if (existing.unconditional || unconditional) {
+              // only add duplicate if at least one is unconditional, or share the same combining parent
+              const isSameParent =
+                parentExpr &&
+                existing.parentExpr === parentExpr &&
+                (parentExpr.type === 'BinaryExpression' ||
+                  parentExpr.type === 'TemplateLiteral')
+
+              if (existing.unconditional || unconditional || isSameParent) {
                 duplicatesInExpression.add(className)
               }
             } else {
               collected.set(className, {
                 node: reportNode.parent,
-                unconditional
+                unconditional,
+                parentExpr
               })
             }
             // track unconditional duplicates separately for reporting

lib/rules/no-duplicate-class-names.js

@@ -76,13 +76,10 @@ module.exports = {
       categories: undefined,
       url: 'https://eslint.vuejs.org/rules/no-negated-v-if-condition.html'
     },
-    fixable: null,
-    hasSuggestions: true,
+    fixable: 'code',
     schema: [],
     messages: {
-      negatedCondition: 'Unexpected negated condition in v-if with v-else.',
-      fixNegatedCondition:
-        'Convert to positive condition and swap if/else blocks.'
+      negatedCondition: 'Unexpected negated condition in v-if with v-else.'
     }
   },
   /** @param {RuleContext} context */
@@ -152,14 +149,7 @@ module.exports = {
       context.report({
         node: expression,
         messageId: 'negatedCondition',
-        suggest: [
-          {
-            messageId: 'fixNegatedCondition',
-            *fix(fixer) {
-              yield* swapElements(fixer, element, elseElement, expression)
-            }
-          }
-        ]
+        fix: (fixer) => swapElements(fixer, element, elseElement, expression)
       })
     }
 

lib/rules/no-negated-v-if-condition.js

@@ -8,40 +8,29 @@ const utils = require('../utils')
 
 /**
  * @typedef ScriptRef
- * @type {{node: Expression, ref: string}}
+ * @type {[string, CallExpression]}
  */
 
-/**
- * @param declarator {VariableDeclarator}
- * @returns {ScriptRef}
- * */
-function convertDeclaratorToScriptRef(declarator) {
-  return {
-    // @ts-ignore
-    node: declarator.init,
-    // @ts-ignore
-    ref: declarator.id.name
-  }
-}
-
 /**
  * @param body {(Statement | ModuleDeclaration)[]}
  * @returns {ScriptRef[]}
  * */
 function getScriptRefsFromSetupFunction(body) {
-  /** @type {VariableDeclaration[]} */
-  const variableDeclarations = body.filter(
-    (child) => child.type === 'VariableDeclaration'
-  )
-  const variableDeclarators = variableDeclarations.map(
-    (declaration) => declaration.declarations[0]
-  )
-  const refDeclarators = variableDeclarators.filter((declarator) =>
-    // @ts-ignore
-    ['ref', 'shallowRef'].includes(declarator.init?.callee?.name)
-  )
+  return body.flatMap((child) => {
+    if (child.type === 'VariableDeclaration') {
+      const declarator = child.declarations[0]
+
+      if (
+        declarator.init?.type === 'CallExpression' &&
+        declarator.init.callee?.type === 'Identifier' &&
+        declarator.id.type === 'Identifier' &&
+        ['ref', 'shallowRef'].includes(declarator.init.callee.name)
+      )
+        return [[declarator.id.name, declarator.init]]
+    }
 
-  return refDeclarators.map(convertDeclaratorToScriptRef)
+    return []
+  })
 }
 
 /** @type {import("eslint").Rule.RuleModule} */
@@ -94,21 +83,20 @@ module.exports = {
       }),
       {
         'Program:exit'() {
+          const scriptRefsMap = new Map(scriptRefs)
+
           for (const templateRef of templateRefs) {
-            const scriptRef = scriptRefs.find(
-              (scriptRef) => scriptRef.ref === templateRef
-            )
+            const scriptRef = scriptRefsMap.get(templateRef)
 
             if (!scriptRef) {
               continue
             }
 
             context.report({
-              node: scriptRef.node,
+              node: scriptRef,
               messageId: 'preferUseTemplateRef',
               data: {
-                // @ts-ignore
-                name: scriptRef.node?.callee?.name
+                name: /** @type {Identifier} */ (scriptRef.callee).name
               }
             })
           }

lib/rules/prefer-use-template-ref.js

@@ -266,6 +266,8 @@
   "DeprecationTypes",
   "createElementVNode",
   "WatchOptionsBase",
+  "nodeOps",
+  "patchProp",
   "TransitionProps",
   "Transition",
   "TransitionGroupProps",