refactor(no-unlocalized-strings): reduce default ignoreProperties

Leverage TypeScript types to detect technical properties automatically:
- Removed type, id, name, href, src, role from defaults (detected via types)
- Removed SVG attributes (detected via types or heuristics)
- Added SVG path data detection to looksLikeUIString heuristic
- Kept only: className, styleName, key, testID, data-testid

Author: swernerx

README.md

@@ -153,6 +153,7 @@ The `no-unlocalized-strings` rule has different options because TypeScript types
 - `useTsTypes: true` — always enabled
 - Most `ignoreFunctions` entries for DOM APIs — auto-detected via types
 - Most `ignoreNames` entries for typed parameters — auto-detected via types
+- Most `ignoreProperties` entries (like `type`, `role`, `href`) — auto-detected via types
 - `ignoreMethodsOnTypes` — handled automatically
 
 ### Migration Steps

docs/rules/no-unlocalized-strings.md

@@ -127,32 +127,30 @@ Wildcard examples:
 
 Array of property/attribute names whose string values should be ignored.
 
+This list is intentionally minimal — most HTML/SVG attributes are detected automatically via TypeScript types (string literal unions like `"button" | "submit"` for `type`).
+
 Default:
 
 ```ts
 [
-  // CSS/styling
-  "className", "styleName", "style",
-  // HTML attributes
-  "type", "id", "key", "name", "href", "src", "role",
-  // Testing
-  "testID", "data-testid",
-  // Accessibility
-  "aria-label", "aria-describedby", "aria-labelledby",
-  // SVG attributes
-  "viewBox", "d", "cx", "cy", "r", "x", "y", "width", "height",
-  "fill", "stroke", "transform", "points", "pathLength"
+  "className",    // CSS classes - arbitrary strings, always technical
+  "styleName",    // CSS modules
+  "key",          // React key prop
+  "testID",       // React Native testing
+  "data-testid"   // DOM testing
 ]
 ```
 
 ```ts
 {
   "lingui-ts/no-unlocalized-strings": ["error", {
-    "ignoreProperties": ["className", "type", "variant", "testId"]
+    "ignoreProperties": ["className", "testId", "myCustomTechnicalProp"]
   }]
 }
 ```
 
+**Note**: Properties like `type`, `role`, `href`, `id` are NOT in the default list because TypeScript automatically detects them as technical when they have string literal union types.
+
 ### `ignoreNames`
 
 Array of variable names to ignore.
@@ -192,6 +190,7 @@ The rule uses heuristics to determine if a string looks like UI text:
 - URLs and paths (`/`, `https://`, `mailto:`)
 - Identifiers without spaces (`myFunction`, `my-css-class`)
 - CSS selectors (`:hover`, `.class`, `#id`)
+- SVG path data (`M10 10`, `L20 30`)
 
 ## When Not To Use It
 

src/rules/no-unlocalized-strings.ts

@@ -24,43 +24,23 @@ const DEFAULT_IGNORE_FUNCTIONS = ["console.*", "require", "import", "Error", "Ty
 
 /**
  * JSX attributes and object properties whose values should not be checked.
- * These are typically technical values, not user-visible text.
+ *
+ * This list is intentionally minimal - most HTML/SVG attributes are detected
+ * automatically via TypeScript types (string literal unions like "button" | "submit").
+ *
+ * We only list properties that:
+ * 1. Accept arbitrary strings (not literal unions) but are still technical
+ * 2. Are framework-specific and not in standard type definitions
  */
 const DEFAULT_IGNORE_PROPERTIES = [
-  // CSS/styling
+  // CSS class names - accept arbitrary strings, always technical
   "className",
   "styleName",
-  "style",
-  // HTML attributes
-  "type",
-  "id",
+  // React-specific
   "key",
-  "name",
-  "href",
-  "src",
-  "role",
-  // Testing
+  // Testing IDs - arbitrary strings, always technical
   "testID",
-  "data-testid",
-  // Accessibility (handled by their own rules usually)
-  "aria-label",
-  "aria-describedby",
-  "aria-labelledby",
-  // SVG attributes
-  "viewBox",
-  "d",
-  "cx",
-  "cy",
-  "r",
-  "x",
-  "y",
-  "width",
-  "height",
-  "fill",
-  "stroke",
-  "transform",
-  "points",
-  "pathLength"
+  "data-testid"
 ]
 
 /**
@@ -193,6 +173,12 @@ function looksLikeUIString(value: string): boolean {
     return false
   }
 
+  // SVG path data: commands like M, L, C, etc. followed by coordinates
+  // Examples: "M10 10", "M0 0 L100 100", "M10,10 L20,20"
+  if (/^[MLHVCSQTAZmlhvcsqtaz][\d\s,.-]+/.test(trimmed)) {
+    return false
+  }
+
   // Non-Latin scripts are almost always user-visible text
   // Ranges: CJK, Hangul, Cyrillic, Arabic, Hebrew, Thai, Hangul Jamo
   if (/[\u3000-\u9fff\uac00-\ud7af\u0400-\u04ff\u0600-\u06ff\u0590-\u05ff\u0e00-\u0e7f\u1100-\u11ff]/.test(trimmed)) {
@@ -448,11 +434,47 @@ function isIntlRelatedType(typeName: string): boolean {
   )
 }
 
+/**
+ * Checks if a type is a string literal union (technical type).
+ */
+function isStringLiteralUnion(type: ts.Type): boolean {
+  if (type.isUnion()) {
+    const hasStringLiteral = type.types.some((t) => t.isStringLiteral() || (t.flags & 128) !== 0)
+    const allTechnical = type.types.every((t) => {
+      // String literal
+      if (t.isStringLiteral() || (t.flags & 128) !== 0) {
+        return true
+      }
+      // Number literal
+      if (t.isNumberLiteral() || (t.flags & 256) !== 0) {
+        return true
+      }
+      // Boolean literals (true/false)
+      if ((t.flags & 512) !== 0 || (t.flags & 1024) !== 0) {
+        return true
+      }
+      // undefined
+      if ((t.flags & 32768) !== 0) {
+        return true
+      }
+      // null
+      if ((t.flags & 65536) !== 0) {
+        return true
+      }
+      return false
+    })
+    return hasStringLiteral && allTechnical
+  }
+  // Single string literal type
+  return type.isStringLiteral() || (type.flags & 128) !== 0
+}
+
 /**
  * Uses TypeScript's type checker to determine if a string is technical.
  *
  * Detects:
  * - String literal union types: type Status = "loading" | "error"
+ * - JSX attribute types: <input type="text" /> (type is "button" | "checkbox" | ...)
  * - Intl API arguments: toLocaleString("en-US", { weekday: "long" })
  * - Discriminated union fields: { type: "add" } | { type: "remove" }
  *
@@ -471,36 +493,8 @@ function isTechnicalStringType(
 
     if (contextualType !== undefined) {
       // Check for string literal unions: "a" | "b" | "c"
-      // Also allow unions with undefined, null, boolean, number
-      if (contextualType.isUnion()) {
-        const hasStringLiteral = contextualType.types.some((t) => t.isStringLiteral() || (t.flags & 128) !== 0)
-        const allTechnical = contextualType.types.every((t) => {
-          // String literal
-          if (t.isStringLiteral() || (t.flags & 128) !== 0) {
-            return true
-          }
-          // Number literal
-          if (t.isNumberLiteral() || (t.flags & 256) !== 0) {
-            return true
-          }
-          // Boolean literals (true/false)
-          if ((t.flags & 512) !== 0 || (t.flags & 1024) !== 0) {
-            return true
-          }
-          // undefined
-          if ((t.flags & 32768) !== 0) {
-            return true
-          }
-          // null
-          if ((t.flags & 65536) !== 0) {
-            return true
-          }
-          return false
-        })
-
-        if (hasStringLiteral && allTechnical) {
-          return true
-        }
+      if (isStringLiteralUnion(contextualType)) {
+        return true
       }
 
       // Check for Intl API types