fix: mixed cross node case

Author: Yizack

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

@@ -233,11 +233,18 @@ module.exports = {
           staticClasses = new Set(getClassNames(String(staticAttr.value.value)))
         }
 
+        /** @type {Set<string>} */
         const reported = new Set()
+
+        /** @type {Set<string>} */
         const duplicatesInExpression = new Set()
+
         /** @type {Map<string, ASTNode>} */
         const seen = new Map()
 
+        /** @type {Map<string, {node: ASTNode, unconditional: boolean}>} */
+        const collected = new Map()
+
         const classNodes = extractClassNodes(node)
         for (const { node: reportNode, unconditional } of classNodes) {
           // report fixable duplicates and collect reported class names
@@ -246,44 +253,53 @@ module.exports = {
             for (const classes of reportedClasses) reported.add(classes)
           }
 
-          // collect duplicates within the expression nodes
-          if (unconditional) {
-            const classList = getRawValue(reportNode)
-            if (typeof classList === 'string') {
-              const classNames = getClassNames(classList)
-              for (const className of classNames) {
-                if (seen.has(className)) {
-                  duplicatesInExpression.add(className)
-                } else {
-                  seen.set(className, reportNode.parent)
-                }
+          // collect all class names and check for cross nodes duplicates
+          const classList = getRawValue(reportNode)
+          if (typeof classList !== 'string') continue
+          const classNames = getClassNames(classList)
+
+          for (const className of classNames) {
+            // skip if already reported by reportDuplicateClasses
+            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) {
+                duplicatesInExpression.add(className)
+              }
+            } else {
+              collected.set(className, {
+                node: reportNode.parent,
+                unconditional
+              })
+            }
+            // track unconditional duplicates separately for reporting
+            if (unconditional) {
+              if (seen.has(className)) {
+                duplicatesInExpression.add(className)
+              } else {
+                seen.set(className, reportNode.parent)
               }
             }
           }
 
-          // report duplicates between static and dynamic class attributes
+          // report cross attribute duplicates
           if (staticClasses) {
-            const classList = getRawValue(reportNode)
-            if (typeof classList === 'string') {
-              const classNames = getClassNames(classList)
-              const intersection = classNames.filter((n) =>
-                staticClasses.has(n)
-              )
-              if (intersection.length > 0 && parent) {
-                context.report({
-                  node: parent,
-                  messageId: 'duplicateClassName',
-                  data: { name: intersection.join(', ') }
-                })
-              }
+            const intersection = classNames.filter((n) => staticClasses.has(n))
+            if (intersection.length > 0 && parent) {
+              context.report({
+                node: parent,
+                messageId: 'duplicateClassName',
+                data: { name: intersection.join(', ') }
+              })
             }
           }
         }
 
-        // report duplicates between dynamic class nodes excluding already reported
-        for (const r of reported) duplicatesInExpression.delete(r)
+        // report cross node duplicates
         for (const className of duplicatesInExpression) {
-          const reportNode = seen.get(className)
+          const reportNode =
+            seen.get(className) || collected.get(className)?.node
           if (reportNode) {
             context.report({
               node: reportNode,

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

@@ -345,6 +345,17 @@ tester.run('no-duplicate-class-names', rule, {
           type: 'BinaryExpression'
         }
       ]
+    },
+    {
+      filename: 'duplicate-class-cross-node-mixed.vue',
+      code: `<template><div :class="['foo', { 'foo': true }]"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'ArrayExpression'
+        }
+      ]
     }
   ]
 })