refactor: rename functions and improve code

Author: Yizack

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

@@ -12,7 +12,7 @@ const utils = require('../utils')
  * @param {Expression} [expression]
  * @return {IterableIterator<{ node: Literal | TemplateElement }>}
  */
-function* extractDuplicateNode(node, expression) {
+function* extractClassNodes(node, expression) {
   const nodeExpression = expression ?? node.value?.expression
   if (!nodeExpression) return
 
@@ -25,8 +25,7 @@ function* extractDuplicateNode(node, expression) {
       for (const prop of nodeExpression.properties) {
         if (
           prop.type === 'Property' &&
-          prop.key &&
-          prop.key.type === 'Literal' &&
+          prop.key?.type === 'Literal' &&
           typeof prop.key.value === 'string' &&
           prop.key.value.includes(' ')
         ) {
@@ -39,28 +38,28 @@ function* extractDuplicateNode(node, expression) {
       for (const element of nodeExpression.elements) {
         if (!element || element.type === 'SpreadElement') continue
 
-        yield* extractDuplicateNode(node, element)
+        yield* extractClassNodes(node, element)
       }
       break
     }
     case 'ConditionalExpression': {
-      yield* extractDuplicateNode(node, nodeExpression.consequent)
-      yield* extractDuplicateNode(node, nodeExpression.alternate)
+      yield* extractClassNodes(node, nodeExpression.consequent)
+      yield* extractClassNodes(node, nodeExpression.alternate)
       break
     }
     case 'TemplateLiteral': {
       for (const quasi of nodeExpression.quasis) {
         yield { node: quasi }
       }
       for (const expr of nodeExpression.expressions) {
-        yield* extractDuplicateNode(node, expr)
+        yield* extractClassNodes(node, expr)
       }
       break
     }
     case 'BinaryExpression': {
       if (nodeExpression.operator === '+') {
-        yield* extractDuplicateNode(node, nodeExpression.left)
-        yield* extractDuplicateNode(node, nodeExpression.right)
+        yield* extractClassNodes(node, nodeExpression.left)
+        yield* extractClassNodes(node, nodeExpression.right)
       }
       break
     }
@@ -71,7 +70,8 @@ function* extractDuplicateNode(node, expression) {
  * @param {string} raw - raw class names string including quotes
  * @returns {string}
  */
-function dedupePreserveSpaces(raw) {
+function removeDuplicateClassNames(raw) {
+  const quote = raw[0]
   const inner = raw.slice(1, -1)
   const tokens = inner.split(/(\s+)/)
 
@@ -128,7 +128,6 @@ function dedupePreserveSpaces(raw) {
     }
   }
 
-  const quote = raw[0]
   return quote + kept.join('') + quote
 }
 
@@ -152,7 +151,7 @@ module.exports = {
      * @param {VLiteral | Literal | TemplateElement | null} node
      */
     function reportDuplicateClasses(node) {
-      if (!node || !node.value) return
+      if (!node?.value) return
 
       const classList =
         typeof node.value === 'object' && 'raw' in node.value
@@ -165,29 +164,26 @@ module.exports = {
       if (classNames.length <= 1) return
 
       const seen = new Set()
-      /** @type {string[]} */
-      const duplicates = []
+      const duplicates = new Set()
 
       for (const className of classNames) {
         if (seen.has(className)) {
-          if (!duplicates.includes(className)) {
-            duplicates.push(className)
-          }
+          duplicates.add(className)
         } else {
           seen.add(className)
         }
       }
 
-      if (duplicates.length === 0) return
+      if (duplicates.size === 0) return
 
       context.report({
         node,
         messageId: 'duplicateClassName',
-        data: { name: duplicates.join(', ') },
+        data: { name: [...duplicates].join(', ') },
         fix: (fixer) => {
           const sourceCode = context.getSourceCode()
           const raw = sourceCode.text.slice(node.range[0], node.range[1])
-          return fixer.replaceText(node, dedupePreserveSpaces(raw))
+          return fixer.replaceText(node, removeDuplicateClassNames(raw))
         }
       })
     }
@@ -203,7 +199,7 @@ module.exports = {
       "VAttribute[directive=true][key.argument.name='class'][value.type='VExpressionContainer']"(
         node
       ) {
-        for (const { node: reportNode } of extractDuplicateNode(node)) {
+        for (const { node: reportNode } of extractClassNodes(node)) {
           reportDuplicateClasses(reportNode)
         }
       }