fix: no-unlocalized-strings rule to ignore string literals in expressions assigned to variables specified in ignoreNames

src/rules/no-unlocalized-strings.ts

@@ -471,24 +471,31 @@
         processTextNode(node)
       },
       'Literal:exit'(node: TSESTree.Literal) {
-        // visited and passed linting
         if (visited.has(node)) return
         const trimmed = `${node.value}`.trim()
         if (!trimmed) return
 
         if (isTextWhiteListed(trimmed)) return
 
-        //
-        // TYPESCRIPT
-        // todo: that doesn't work
-        // if (tsService) {
-        //   const typeObj = tsService.getTypeAtLocation(node.parent)
-        //
-        //   // var a: 'abc' = 'abc'
-        //   if (typeObj.isStringLiteral() && typeObj.symbol) {
-        //     return
-        //   }
-        // }
+        // Check if this literal is part of a VariableDeclarator or AssignmentExpression with id/name in ignoreNames
+        let parent = node.parent
+        while (parent) {
+          if (parent.type === TSESTree.AST_NODE_TYPES.VariableDeclarator) {
+            const variableDeclarator = parent as TSESTree.VariableDeclarator
+            if (isIdentifier(variableDeclarator.id) && isIgnoredName(variableDeclarator.id.name)) {
+              return // Do not report this literal
+            }
+          } else if (parent.type === TSESTree.AST_NODE_TYPES.AssignmentExpression) {
+            const assignmentExpression = parent as TSESTree.AssignmentExpression
+            if (
+              isIdentifier(assignmentExpression.left) &&
+              isIgnoredName(assignmentExpression.left.name)
+            ) {
+              return // Do not report this literal
+            }
+          }
+          parent = parent.parent
+        }
 
         context.report({ node, messageId: 'default' })
       },
@@ -498,6 +505,26 @@
 
         if (!text || isTextWhiteListed(text)) return
 
+        // Check if this template literal is part of a VariableDeclarator or AssignmentExpression with id/name in ignoreNames
+        let parent = node.parent
+        while (parent) {
+          if (parent.type === TSESTree.AST_NODE_TYPES.VariableDeclarator) {
+            const variableDeclarator = parent as TSESTree.VariableDeclarator
+            if (isIdentifier(variableDeclarator.id) && isIgnoredName(variableDeclarator.id.name)) {
+              return // Do not report this template literal
+            }
+          } else if (parent.type === TSESTree.AST_NODE_TYPES.AssignmentExpression) {
+            const assignmentExpression = parent as TSESTree.AssignmentExpression
+            if (
+              isIdentifier(assignmentExpression.left) &&
+              isIgnoredName(assignmentExpression.left.name)
+            ) {
+              return // Do not report this template literal
+            }
+          }
+          parent = parent.parent
+        }
+
         context.report({ node, messageId: 'default' })
       },
 

tests/src/rules/no-unlocalized-strings.test.ts

@@ -216,6 +216,31 @@ ruleTester.run<string, Option[]>(name, rule, {
       name: 'computed keys should be ignored by default with TplLiteral',
       code: `obj[\`key with space\`] = 5`,
     },
+    {
+      name: 'Supports default value assignment',
+      code: 'const variant = input || "body"',
+      options: [{ ignoreNames: ['variant'] }],
+    },
+    {
+      name: 'Supports nullish coalescing operator',
+      code: 'const variant = input ?? "body"',
+      options: [{ ignoreNames: ['variant'] }],
+    },
+    {
+      name: 'Supports ternary operator',
+      code: 'const value = condition ? "yes" : "no"',
+      options: [{ ignoreNames: ['value'] }],
+    },
+    {
+      name: 'Ignores literals in assignment expression after variable declaration',
+      code: `let variant; variant = input ?? "body";`,
+      options: [{ ignoreNames: ['variant'] }],
+    },
+    {
+      name: 'Ignores literals in assignment expression to variable in ignoreNames',
+      code: `let variant; variant = "body";`,
+      options: [{ ignoreNames: ['variant'] }],
+    },
     {
       code: `const test = "Hello!"`,
       options: [{ ignoreNames: ['test'] }],
@@ -296,6 +321,12 @@ ruleTester.run<string, Option[]>(name, rule, {
     { code: 'export const a = `hello string`;', errors },
     { code: "const ge = 'Select tax code'", errors },
     { code: 'const a = `Foo`;', errors },
+    {
+      name: 'Reports error when variable name is not in ignoreNames',
+      code: 'const other = input ?? "body";',
+      options: [{ ignoreNames: ['variant'] }],
+      errors: [{ messageId: 'default', line: 1, column: 24 }],
+    },
     { code: 'const a = call(`Ffo`);', errors },
     { code: 'var a = {foo: `Bar`};', errors },
     {