fix(rules): correct plural handling

- Remove i18n.plural/select from default allowedCallees
- Rewrite consistent-plural-format for <Plural> component props
- plural() is not a helper like i18n.date - use <Plural> component

Author: swernerx

docs/rules/consistent-plural-format.md

@@ -1,52 +1,49 @@
 # consistent-plural-format
 
-Ensure consistent plural usage with required keys.
+Ensure `<Plural>` component has required plural category props.
 
 ## Why?
 
-Proper pluralization requires specific keys for different quantities. Missing keys can cause:
+Proper pluralization requires specific props for different quantities. Missing props can cause:
 - Runtime errors or fallback to incorrect text
 - Incomplete translations
 - Poor user experience for different languages
 
 ## Rule Details
 
-This rule ensures that `plural()` calls include all required plural keys.
+This rule ensures that `<Plural>` components include all required plural category props.
 
 ### ❌ Invalid
 
 ```tsx
 // Missing 'other' (required by default)
-plural(count, { one: '# item' })
+<Plural value={count} one="# item" />
 
 // Missing 'one' (required by default)
-plural(count, { other: '# items' })
+<Plural value={count} other="# items" />
 
-// Missing both required keys
-plural(count, { zero: 'None' })
-
-// With i18n prefix
-i18n.plural(count, { one: '# item' })  // Missing 'other'
+// Missing both required props
+<Plural value={count} zero="None" />
 ```
 
 ### ✅ Valid
 
 ```tsx
-// All required keys present
-plural(count, { one: '# item', other: '# items' })
+// All required props present
+<Plural value={count} one="# item" other="# items" />
 
-// Additional keys are allowed
-plural(count, { one: 'One', other: 'Many', zero: 'None' })
+// Additional props are allowed
+<Plural value={count} one="One" other="Many" zero="None" />
 
-// With i18n prefix
-i18n.plural(count, { one: '# item', other: '# items' })
+// With expressions
+<Plural value={count} one={oneMsg} other={otherMsg} />
 ```
 
 ## Options
 
 ### `requiredKeys`
 
-Array of plural keys that must be present. Default: `["one", "other"]`
+Array of plural category props that must be present. Default: `["one", "other"]`
 
 Common CLDR plural categories: `zero`, `one`, `two`, `few`, `many`, `other`
 
@@ -68,5 +65,4 @@ Common CLDR plural categories: `zero`, `one`, `two`, `few`, `many`, `other`
 
 ## When Not To Use It
 
-If your project uses a different pluralization approach or handles missing keys gracefully at runtime, you can disable this rule.
-
+If your project uses ICU message format directly in `t` strings instead of `<Plural>` components, this rule won't help. It only checks JSX `<Plural>` components.

docs/rules/no-complex-expressions-in-message.md

@@ -48,7 +48,7 @@ t`Hello ${name}`
 // Whitelisted Lingui helpers
 t`Price: ${i18n.number(price)}`
 t`Date: ${i18n.date(date)}`
-<Trans>Items: {i18n.plural(count, { one: '#', other: '#' })}</Trans>
+<Trans>Price: {i18n.number(price)}</Trans>
 
 // Extract complex logic first
 const displayPrice = price * 1.2
@@ -64,7 +64,7 @@ const formattedDate = formatDate(date)
 
 Array of function names that are allowed. Format: dot-separated strings.
 
-Default: `["i18n.number", "i18n.date", "i18n.plural", "i18n.select"]`
+Default: `["i18n.number", "i18n.date"]`
 
 ```ts
 {

src/rules/consistent-plural-format.test.ts

@@ -11,80 +11,74 @@ const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
       ecmaVersion: 2022,
-      sourceType: "module"
+      sourceType: "module",
+      ecmaFeatures: {
+        jsx: true
+      }
     }
   }
 })
 
 ruleTester.run("consistent-plural-format", consistentPluralFormat, {
   valid: [
-    // All required keys present (default: one, other)
-    "plural(count, { one: '# item', other: '# items' })",
-    "plural(count, { one: 'One', other: 'Many', zero: 'None' })",
+    // All required props present (default: one, other)
+    '<Plural value={count} one="# item" other="# items" />',
+    '<Plural value={count} one="One" other="Many" zero="None" />',
 
-    // With i18n prefix
-    "i18n.plural(count, { one: '# item', other: '# items' })",
+    // With expressions
+    "<Plural value={count} one={oneMsg} other={otherMsg} />",
 
     // Custom required keys
     {
-      code: "plural(count, { other: 'items' })",
+      code: '<Plural value={count} other="items" />',
       options: [{ requiredKeys: ["other"] }]
     },
     {
-      code: "plural(count, { one: '#', other: '#', zero: 'none' })",
+      code: '<Plural value={count} one="#" other="#" zero="none" />',
       options: [{ requiredKeys: ["one", "other", "zero"] }]
     },
 
-    // Non-plural calls should be ignored
-    "select(value, { male: 'He', female: 'She', other: 'They' })",
-    "someOtherFunction({ one: 'x' })",
-
-    // No object argument (edge case)
-    "plural(count)"
+    // Non-Plural components should be ignored
+    '<Select value={gender} male="He" female="She" other="They" />',
+    '<div one="x" />',
+    "<Trans>Hello</Trans>"
   ],
   invalid: [
     // Missing 'other' (default required)
     {
-      code: "plural(count, { one: '# item' })",
+      code: '<Plural value={count} one="# item" />',
       errors: [{ messageId: "missingPluralKey", data: { key: "other" } }]
     },
 
     // Missing 'one' (default required)
     {
-      code: "plural(count, { other: '# items' })",
+      code: '<Plural value={count} other="# items" />',
       errors: [{ messageId: "missingPluralKey", data: { key: "one" } }]
     },
 
     // Missing both default required keys
     {
-      code: "plural(count, { zero: 'None' })",
+      code: '<Plural value={count} zero="None" />',
       errors: [
         { messageId: "missingPluralKey", data: { key: "one" } },
         { messageId: "missingPluralKey", data: { key: "other" } }
       ]
     },
 
-    // With i18n prefix
-    {
-      code: "i18n.plural(count, { one: '# item' })",
-      errors: [{ messageId: "missingPluralKey", data: { key: "other" } }]
-    },
-
     // Custom required keys missing
     {
-      code: "plural(count, { one: '#', other: '#' })",
+      code: '<Plural value={count} one="#" other="#" />',
       options: [{ requiredKeys: ["one", "other", "zero"] }],
       errors: [{ messageId: "missingPluralKey", data: { key: "zero" } }]
     },
 
-    // Empty object
+    // Only value prop
     {
-      code: "plural(count, {})",
+      code: "<Plural value={count} />",
       errors: [
         { messageId: "missingPluralKey", data: { key: "one" } },
         { messageId: "missingPluralKey", data: { key: "other" } }
       ]
     }
   ]
 })
-

src/rules/consistent-plural-format.ts

@@ -11,68 +11,29 @@ interface Options {
 const DEFAULT_REQUIRED_KEYS = ["one", "other"]
 
 /**
- * Extracts property keys from an object expression.
+ * Extracts attribute names from a JSX opening element.
  */
-function getObjectKeys(node: TSESTree.ObjectExpression): string[] {
-  const keys: string[] = []
+function getJSXAttributeNames(node: TSESTree.JSXOpeningElement): string[] {
+  const names: string[] = []
 
-  for (const property of node.properties) {
-    if (property.type === AST_NODE_TYPES.Property) {
-      if (property.key.type === AST_NODE_TYPES.Identifier) {
-        keys.push(property.key.name)
-      } else if (property.key.type === AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
-        keys.push(property.key.value)
-      }
+  for (const attr of node.attributes) {
+    if (attr.type === AST_NODE_TYPES.JSXAttribute && attr.name.type === AST_NODE_TYPES.JSXIdentifier) {
+      names.push(attr.name.name)
     }
   }
 
-  return keys
-}
-
-/**
- * Checks if a call expression is a plural helper call.
- */
-function isPluralCall(node: TSESTree.CallExpression): boolean {
-  // Check for: plural(...)
-  if (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "plural") {
-    return true
-  }
-
-  // Check for: i18n.plural(...)
-  if (
-    node.callee.type === AST_NODE_TYPES.MemberExpression &&
-    node.callee.property.type === AST_NODE_TYPES.Identifier &&
-    node.callee.property.name === "plural"
-  ) {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Gets the options object from a plural call.
- * plural(count, { one: '...', other: '...' })
- */
-function getPluralOptionsObject(node: TSESTree.CallExpression): TSESTree.ObjectExpression | null {
-  // Expected format: plural(value, { ... }) or plural({ value, ... })
-  for (const arg of node.arguments) {
-    if (arg.type === AST_NODE_TYPES.ObjectExpression) {
-      return arg
-    }
-  }
-  return null
+  return names
 }
 
 export const consistentPluralFormat = createRule<[Options], MessageId>({
   name: "consistent-plural-format",
   meta: {
     type: "problem",
     docs: {
-      description: "Ensure consistent plural usage with required keys"
+      description: "Ensure <Plural> component has required plural category props"
     },
     messages: {
-      missingPluralKey: "Plural is missing required key '{{key}}'"
+      missingPluralKey: "<Plural> is missing required prop '{{key}}'"
     },
     schema: [
       {
@@ -95,20 +56,21 @@ export const consistentPluralFormat = createRule<[Options], MessageId>({
   ],
   create(context, [options]) {
     return {
-      CallExpression(node): void {
-        if (!isPluralCall(node)) {
+      JSXElement(node): void {
+        const openingElement = node.openingElement
+
+        // Check for <Plural> component
+        if (
+          openingElement.name.type !== AST_NODE_TYPES.JSXIdentifier ||
+          openingElement.name.name !== "Plural"
+        ) {
           return
         }
 
-        const optionsObject = getPluralOptionsObject(node)
-        if (optionsObject === null) {
-          return
-        }
-
-        const providedKeys = getObjectKeys(optionsObject)
+        const providedProps = getJSXAttributeNames(openingElement)
 
         for (const requiredKey of options.requiredKeys) {
-          if (!providedKeys.includes(requiredKey)) {
+          if (!providedProps.includes(requiredKey)) {
             context.report({
               node,
               messageId: "missingPluralKey",
@@ -120,4 +82,3 @@ export const consistentPluralFormat = createRule<[Options], MessageId>({
     }
   }
 })
-

src/rules/no-complex-expressions-in-message.test.ts

@@ -30,11 +30,11 @@ ruleTester.run("no-complex-expressions-in-message", noComplexExpressionsInMessag
     "<Trans>Hello {name}</Trans>",
     "<Trans>You have {count} items</Trans>",
 
-    // Allowed callees (default: i18n.number, i18n.date, etc.)
+    // Allowed callees (default: i18n.number, i18n.date)
     "t`Price: ${i18n.number(price)}`",
     "t`Date: ${i18n.date(date)}`",
     "<Trans>Price: {i18n.number(price)}</Trans>",
-    "<Trans>Items: {i18n.plural(count, { one: '#', other: '#' })}</Trans>",
+    "<Trans>Date: {i18n.date(date)}</Trans>",
 
     // Member expressions when allowed
     {

src/rules/no-complex-expressions-in-message.ts

@@ -10,7 +10,7 @@ interface Options {
   maxExpressionDepth: number | null
 }
 
-const DEFAULT_ALLOWED_CALLEES = ["i18n.number", "i18n.date", "i18n.plural", "i18n.select"]
+const DEFAULT_ALLOWED_CALLEES = ["i18n.number", "i18n.date"]
 
 /**
  * Gets the string representation of a callee (e.g., "i18n.number", "Math.random").