refactor(no-unlocalized-strings): type-based Console/Error detection, minimal defaults

DEFAULT_IGNORE_FUNCTIONS: require, import (Console/Error auto-detected via types)
DEFAULT_IGNORE_PROPERTIES: className, key, data-testid (3 entries)

Added type-aware detection:
- isConsoleMethodArgument() - detects Console type
- isErrorConstructorArgument() - detects Error type hierarchy

Author: swernerx

README.md

@@ -144,7 +144,7 @@ The `no-unlocalized-strings` rule has different options because TypeScript types
 |-----------------|-------------|-------|
 | `useTsTypes` | — | Always enabled (TypeScript required) |
 | `ignore` (array of regex) | `ignorePattern` (single regex) | Simplified |
-| `ignoreFunctions` | `ignoreFunctions` | ✅ Compatible (wildcards work slightly differently) |
+| `ignoreFunctions` | `ignoreFunctions` | ✅ Simplified (Console/Error auto-detected) |
 | `ignoreNames` (with regex support) | `ignoreNames` | Simplified (no regex, plain strings only) |
 | — | `ignoreProperties` | New: separate option for JSX attributes and object properties |
 | `ignoreMethodsOnTypes` | — | Not needed (TypeScript handles this automatically) |

docs/rules/no-unlocalized-strings.md

@@ -108,20 +108,24 @@ const action = { type: "save" }  // ✅ Not reported (type/kind properties)
 
 Array of function names whose string arguments should be ignored. Supports wildcards.
 
-Default: `["console.*", "require", "import", "Error", "TypeError", "RangeError", "SyntaxError"]`
+Default: `["require", "import"]`
+
+Most common cases are detected automatically via TypeScript types:
+- **Console methods** (`console.log`, `console.error`, etc.) — detected via `Console` type
+- **Error constructors** (`new Error()`, `new TypeError()`, etc.) — detected via Error type hierarchy
 
 ```ts
 {
   "lingui-ts/no-unlocalized-strings": ["error", {
-    "ignoreFunctions": ["console.*", "require", "logger.*", "analytics.track"]
+    "ignoreFunctions": ["require", "import", "logger.*", "analytics.track"]
   }]
 }
 ```
 
 Wildcard examples:
 
-- `"console.*"` matches `console.log`, `console.error`, etc.
-- `"*.debug"` matches `logger.debug`, `app.debug`, etc.
+- `"logger.*"` matches `logger.debug`, `logger.info`, etc.
+- `"*.track"` matches `analytics.track`, `events.track`, etc.
 
 ### `ignoreProperties`
 
@@ -134,10 +138,8 @@ Default:
 ```ts
 [
   "className",    // CSS classes - arbitrary strings, always technical
-  "styleName",    // CSS modules
   "key",          // React key prop
-  "testID",       // React Native testing
-  "data-testid"   // DOM testing
+  "data-testid"   // DOM Testing Library standard
 ]
 ```
 

src/rules/no-unlocalized-strings.ts

@@ -19,8 +19,11 @@ export interface Options {
 /**
  * Functions whose arguments should not be checked for localization.
  * Supports wildcards: "console.*" matches console.log, console.error, etc.
+ *
+ * This list is intentionally minimal - Error constructors and console methods
+ * are detected automatically via TypeScript types.
  */
-const DEFAULT_IGNORE_FUNCTIONS = ["console.*", "require", "import", "Error", "TypeError", "RangeError", "SyntaxError"]
+const DEFAULT_IGNORE_FUNCTIONS = ["require", "import"]
 
 /**
  * JSX attributes and object properties whose values should not be checked.
@@ -35,11 +38,9 @@ const DEFAULT_IGNORE_FUNCTIONS = ["console.*", "require", "import", "Error", "Ty
 const DEFAULT_IGNORE_PROPERTIES = [
   // CSS class names - accept arbitrary strings, always technical
   "className",
-  "styleName",
-  // React-specific
+  // React key prop
   "key",
-  // Testing IDs - arbitrary strings, always technical
-  "testID",
+  // Testing ID - DOM Testing Library standard
   "data-testid"
 ]
 
@@ -297,6 +298,86 @@ function isIgnoredFunctionArgument(node: TSESTree.Node, ignoreFunctions: string[
   return false
 }
 
+/**
+ * Checks if a string is an argument to a Console method (console.log, etc.)
+ * using TypeScript type information.
+ */
+function isConsoleMethodArgument(
+  node: TSESTree.Node,
+  typeChecker: ts.TypeChecker,
+  parserServices: ReturnType<typeof ESLintUtils.getParserServices>
+): boolean {
+  const parent = node.parent
+  if (parent?.type !== AST_NODE_TYPES.CallExpression) {
+    return false
+  }
+
+  const callee = parent.callee
+  if (callee.type !== AST_NODE_TYPES.MemberExpression) {
+    return false
+  }
+
+  try {
+    const objectTsNode = parserServices.esTreeNodeToTSNodeMap.get(callee.object)
+    const objectType = typeChecker.getTypeAtLocation(objectTsNode)
+    const typeName = typeChecker.typeToString(objectType)
+
+    // Check if the object is of type Console
+    return typeName === "Console"
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Checks if a string is an argument to an Error constructor
+ * using TypeScript type information.
+ */
+function isErrorConstructorArgument(
+  node: TSESTree.Node,
+  typeChecker: ts.TypeChecker,
+  parserServices: ReturnType<typeof ESLintUtils.getParserServices>
+): boolean {
+  const parent = node.parent
+  if (parent?.type !== AST_NODE_TYPES.NewExpression) {
+    return false
+  }
+
+  try {
+    const calleeTsNode = parserServices.esTreeNodeToTSNodeMap.get(parent.callee)
+    const calleeType = typeChecker.getTypeAtLocation(calleeTsNode)
+
+    // Check if the constructor creates an Error type
+    const constructSignatures = calleeType.getConstructSignatures()
+    for (const sig of constructSignatures) {
+      const returnType = sig.getReturnType()
+      const returnTypeName = typeChecker.typeToString(returnType)
+
+      // Check if it returns Error or any Error subtype
+      if (returnTypeName === "Error" || returnTypeName.endsWith("Error")) {
+        return true
+      }
+
+      // Check if the return type extends Error
+      if ("getBaseTypes" in returnType && typeof returnType.getBaseTypes === "function") {
+        const baseTypes = returnType.getBaseTypes()
+        if (baseTypes !== undefined) {
+          for (const baseType of baseTypes) {
+            const baseTypeName = typeChecker.typeToString(baseType)
+            if (baseTypeName === "Error") {
+              return true
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return false
+  }
+
+  return false
+}
+
 /**
  * Checks if a string is a value for an ignored property/attribute.
  */
@@ -636,6 +717,16 @@ export const noUnlocalizedStrings = createRule<[Options], MessageId>({
         return
       }
 
+      // Console method argument (type-aware)
+      if (isConsoleMethodArgument(node, typeChecker, parserServices)) {
+        return
+      }
+
+      // Error constructor argument (type-aware)
+      if (isErrorConstructorArgument(node, typeChecker, parserServices)) {
+        return
+      }
+
       // Value for ignored property
       if (isIgnoredProperty(node, options.ignoreProperties)) {
         return