crates/biome_js_analyze/src/react.rs (1)

338-345: Consider validating import source.

Unlike is_global_react_import (which checks declaration type and import source), this function only checks the binding name. This might match local variables with the same name as the factory.

If the JSX factory configuration expects imports from specific modules (e.g., 'preact'), consider adding source validation similar to is_global_react_import.

crates/biome_configuration/src/javascript/mod.rs (1)

48-60: JSX factory fields: good addition; consider normalising inputs

Two minor polish items:

• Trim whitespace on values at read time to avoid config nits.
• Clarify in rustdoc that these should be base identifiers (before any dot), since downstream code often expects that.

Happy path as-is; these are non-blocking.

crates/biome_js_analyze/tests/spec_tests.rs (1)

182-200: Avoid double tsconfig lookup and trim identifiers

• Query tsconfig once and reuse for factory + fragment.
• Trim the identifiers to be safe.

Example tweak:

-    if options.jsx_runtime() == Some(JsxRuntime::ReactClassic) {
-        if options.jsx_factory().is_none() {
-            let factory = project_layout.query_tsconfig_for_path(input_file, |tsconfig| {
-                tsconfig.jsx_factory_identifier().map(|s| s.to_string())
-            }).flatten();
-            options.set_jsx_factory(factory.map(|s| s.into()));
-        }
-        if options.jsx_fragment_factory().is_none() {
-            let fragment_factory = project_layout.query_tsconfig_for_path(input_file, |tsconfig| {
-                tsconfig.jsx_fragment_factory_identifier().map(|s| s.to_string())
-            }).flatten();
-            options.set_jsx_fragment_factory(fragment_factory.map(|s| s.into()));
-        }
-    }
+    if options.jsx_runtime() == Some(JsxRuntime::ReactClassic) {
+        if options.jsx_factory().is_none() || options.jsx_fragment_factory().is_none() {
+            if let Some(tsconfig) = project_layout.find_tsconfig_for_path(input_file) {
+                if options.jsx_factory().is_none() {
+                    let f = tsconfig.jsx_factory_identifier().map(|s| s.trim().to_string());
+                    options.set_jsx_factory(f.map(Into::into));
+                }
+                if options.jsx_fragment_factory().is_none() {
+                    let ff = tsconfig.jsx_fragment_factory_identifier().map(|s| s.trim().to_string());
+                    options.set_jsx_fragment_factory(ff.map(Into::into));
+                }
+            }
+        }
+    }

crates/biome_js_analyze/src/lint/correctness/no_unused_imports.rs (1)

626-642: Nice exemption for custom JSX factories; consider sharing helper

Logic is sound and fixes the false positives. To DRY with use_import_type, extract a shared helper (e.g. react::is_jsx_factory_binding(binding, ctx)) so both rules stay in lockstep when this grows.

crates/biome_analyze/src/context.rs (1)

164-172: Doc nudge: clarify expected shape of identifiers

Please mention these are base identifiers (pre‑dot), e.g. “React” not “React.createElement”, matching what services/options pass in. Keeps invariants obvious for rule authors.

crates/biome_service/src/file_handlers/javascript.rs (1)

346-359: Minor normalisation: trim and gate by runtime

Two tiny tweaks:

• Trim before split to avoid stray spaces.
• Optionally only forward factories when runtime is ReactClassic (purely to reduce surprise).

Example:

-        let jsx_factory = environment
+        let jsx_factory = (matches!(jsx_runtime, biome_analyze::options::JsxRuntime::ReactClassic))
+            .then_some(environment)
             .and_then(|env| env.jsx_factory.as_ref())
-            .and_then(|factory| factory.split('.').next())
+            .map(|s| s.trim())
+            .and_then(|factory| factory.split('.').next())
             .map(|s| s.into());
-        let jsx_fragment_factory = environment
+        let jsx_fragment_factory = (matches!(jsx_runtime, biome_analyze::options::JsxRuntime::ReactClassic))
+            .then_some(environment)
             .and_then(|env| env.jsx_fragment_factory.as_ref())
-            .and_then(|factory| factory.split('.').next())
+            .map(|s| s.trim())
+            .and_then(|factory| factory.split('.').next())
             .map(|s| s.into());

crates/biome_package/src/node_js_package/tsconfig_json.rs (1)

120-136: Trim before splitting to be tolerant of whitespace

A tiny guard improves resilience:

-    pub fn jsx_factory_identifier(&self) -> Option<&str> {
-        self.compiler_options
-            .jsx_factory
-            .as_ref()
-            .map(|factory| factory.split('.').next().unwrap_or(factory.as_str()))
-    }
+    pub fn jsx_factory_identifier(&self) -> Option<&str> {
+        self.compiler_options.jsx_factory.as_deref().map(|factory| {
+            let f = factory.trim();
+            f.split('.').next().unwrap_or(f)
+        })
+    }

Apply the same to jsx_fragment_factory_identifier.

crates/biome_js_analyze/src/lint/style/use_import_type.rs (1)

1101-1129: Centralise is_jsx_factory_binding to avoid drift

Great extraction. Consider moving this to crate::react (public helper) so both this rule and noUnusedImports share one source of truth for JSX‑factory recognition. Less chance of future divergence.

crates/biome_analyze/src/options.rs (1)

179-193: Consider adding rustdoc and reordering methods.

Two suggestions to improve maintainability:

1. Missing rustdoc comments: Per the coding guidelines, "Document rules, assists, and options with inline rustdoc in source". These public API methods should have doc comments explaining their purpose and return values.

2. Method ordering: Grouping each field's getter and setter together would improve readability. Current order (jsx_factory getter → factory setter → fragment setter → fragment getter) is a bit unusual.

Example improvement:

+    /// Returns the configured JSX factory identifier, if any (e.g., "h" for Preact).
     pub fn jsx_factory(&self) -> Option<&str> {
         self.configuration.jsx_factory.as_deref()
     }
 
+    /// Sets the JSX factory identifier for the classic JSX runtime.
     pub fn set_jsx_factory(&mut self, jsx_factory: Option<Box<str>>) {
         self.configuration.jsx_factory = jsx_factory;
     }
 
-    pub fn set_jsx_fragment_factory(&mut self, jsx_fragment_factory: Option<Box<str>>) {
-        self.configuration.jsx_fragment_factory = jsx_fragment_factory;
-    }
-
+    /// Returns the configured JSX fragment factory identifier, if any (e.g., "Fragment").
     pub fn jsx_fragment_factory(&self) -> Option<&str> {
         self.configuration.jsx_fragment_factory.as_deref()
     }
+
+    /// Sets the JSX fragment factory identifier for the classic JSX runtime.
+    pub fn set_jsx_fragment_factory(&mut self, jsx_fragment_factory: Option<Box<str>>) {
+        self.configuration.jsx_fragment_factory = jsx_fragment_factory;
+    }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.139Z
Learning: Applies to crates/biome_analyze/**/lib/src/{lint,assist}/**/*.rs : Retrieve rule options via ctx.options() inside rules; do not manually handle overrides/extends resolution

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.139Z
Learning: Applies to crates/biome_analyze/**/lib/src/{lint,assist}/**/*.rs : Set the language field in declare_lint_rule! to the most specific applicable language (js, jsx, ts, or tsx)

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-10-15T09:20:19.139Z
Learning: Applies to crates/biome_analyze/**/tests/quick_test.rs : Use the quick test at biome_js_analyze/tests/quick_test.rs by un-ignoring and adjusting SOURCE and RuleFilter for ad-hoc checks