feat(transformer): Support nested member expressions in React Fast Refresh

Add support for detecting hooks called via nested member expressions like
`FancyHook.property.useNestedThing()` in React Fast Refresh.

Previously, only direct hook calls and single-level member expressions were
supported. This caused nested member expression hooks to force a full reset
on HMR instead of preserving state.

This implementation matches React PR #35318:
facebook/react#35318

Co-authored-by: Dunqing <[email protected]>

Author: Copilot

crates/oxc_transformer/src/jsx/refresh.rs

@@ -335,13 +335,23 @@ impl<'a> Traverse<'a, TransformState<'a>> for ReactRefresh<'a, '_> {
 
         if !is_builtin_hook(&hook_name) {
             // Check if a corresponding binding exists where we emit the signature.
-            let (binding_name, is_member_expression) = match &call_expr.callee {
-                Expression::Identifier(ident) => (Some(ident.name), false),
+            // Extract the root binding name and member path for custom hooks
+            let (binding_name, member_path) = match &call_expr.callee {
+                Expression::Identifier(ident) => (Some(ident.name), None),
                 Expression::StaticMemberExpression(member) => {
                     if let Expression::Identifier(object) = &member.object {
-                        (Some(object.name), true)
+                        // Simple member: FancyHook.useHook
+                        (Some(object.name), Some(vec![hook_name]))
+                    } else if let Expression::StaticMemberExpression(nested_member) = &member.object
+                    {
+                        // Nested member: FancyHook.property.useHook
+                        if let Expression::Identifier(object) = &nested_member.object {
+                            (Some(object.name), Some(vec![nested_member.property.name, hook_name]))
+                        } else {
+                            (None, None)
+                        }
                     } else {
-                        (None, false)
+                        (None, None)
                     }
                 }
                 _ => unreachable!(),
@@ -362,14 +372,16 @@ impl<'a> Traverse<'a, TransformState<'a>> for ReactRefresh<'a, '_> {
                                 ReferenceFlags::Read,
                             );
 
-                            if is_member_expression {
-                                // binding_name.hook_name
-                                expr = Expression::from(ctx.ast.member_expression_static(
-                                    SPAN,
-                                    expr,
-                                    ctx.ast.identifier_name(SPAN, hook_name),
-                                    false,
-                                ));
+                            if let Some(path) = member_path {
+                                // Build the full member expression chain
+                                for property_name in path {
+                                    expr = Expression::from(ctx.ast.member_expression_static(
+                                        SPAN,
+                                        expr,
+                                        ctx.ast.identifier_name(SPAN, property_name),
+                                        false,
+                                    ));
+                                }
                             }
                             expr
                         }),

tasks/transform_conformance/tests/babel-plugin-transform-react-jsx/test/fixtures/refresh/react-refresh/generates-valid-signature-for-nested-ways-to-call-hooks/input.jsx

@@ -0,0 +1,6 @@
+import FancyHook from 'fancy';
+
+export default function App() {
+  const foo = FancyHook.property.useNestedThing();
+  return <h1>{foo}</h1>;
+}

tasks/transform_conformance/tests/babel-plugin-transform-react-jsx/test/fixtures/refresh/react-refresh/generates-valid-signature-for-nested-ways-to-call-hooks/output.js

@@ -0,0 +1,14 @@
+import FancyHook from "fancy";
+import { jsx as _jsx } from "react/jsx-runtime";
+var _s = $RefreshSig$();
+export default function App() {
+  _s();
+  const foo = FancyHook.property.useNestedThing();
+  return /* @__PURE__ */ _jsx("h1", { children: foo });
+}
+_s(App, "useNestedThing{foo}", false, function () {
+  return [FancyHook.property.useNestedThing];
+});
+_c = App;
+var _c;
+$RefreshReg$(_c, "App");