@reckona/mreact-compiler 0.0.97 → 0.0.98

package/src/oxc-child-analysis.ts

@@ -2,6 +2,7 @@ import {
   invalidJsxExpressionDiagnostic,
   unserializableAwaitValueDiagnostic,
   unsupportedComponentReferenceDiagnostic,
+  unsupportedJsxSpreadChildDiagnostic,
 } from "./diagnostics.js";
 import type { AsyncBoundaryIr, JsxElementIr, JsxNodeIr } from "./ir.js";
 import type { OxcBodyStatementJsxMode } from "./oxc-analysis-types.js";
@@ -135,7 +136,14 @@ export function analyzeOxcJsxNode(
     const analyzeJsxNode = (
       child: Record<string, unknown>,
       childBodyStatementJsx: OxcBodyStatementJsxMode = bodyStatementJsx,
-    ) => analyzeOxcJsxNode(code, child, context, childBodyStatementJsx);
+      shadowNames: readonly string[] = [],
+    ) =>
+      analyzeOxcJsxNode(
+        code,
+        child,
+        shadowOxcReactiveAliases(context, shadowNames),
+        childBodyStatementJsx,
+      );
     const consumerRenderProp = tagName.endsWith(".Consumer")
       ? readOxcConsumerRenderProp(
           code,
@@ -344,6 +352,11 @@ export function analyzeOxcChildren(
       );
     }
 
+    if (object.type === "JSXSpreadChild") {
+      context.diagnostics.push(unsupportedJsxSpreadChildDiagnostic(getOxcLocation(code, object)));
+      return [];
+    }
+
     return [];
   });
 }
@@ -401,17 +414,22 @@ export function analyzeOxcExpressionChild(
       bodyStatementJsx,
     );
 
+    const leftExpression = readObject(unwrappedExpression.left);
+    const conditionValueName = logicalConditionValueName(leftExpression);
+
     if (unwrappedExpression.operator === "&&") {
       return [
         {
           kind: "conditional",
-          conditionCode: readOxcReactiveExpressionCode(
-            code,
-            readObject(unwrappedExpression.left),
-            context,
-          ),
+          conditionCode: readOxcReactiveExpressionCode(code, leftExpression, context),
+          conditionValueName,
           whenTrue: rightBranch,
-          whenFalse: [],
+          whenFalse: [
+            {
+              kind: "expr",
+              code: renderableFalsyConditionValueCode(conditionValueName),
+            },
+          ],
         },
       ];
     }
@@ -420,19 +438,12 @@ export function analyzeOxcExpressionChild(
       return [
         {
           kind: "conditional",
-          conditionCode: readOxcReactiveExpressionCode(
-            code,
-            readObject(unwrappedExpression.left),
-            context,
-          ),
+          conditionCode: readOxcReactiveExpressionCode(code, leftExpression, context),
+          conditionValueName,
           whenTrue: [
             {
               kind: "expr",
-              code: readOxcReactiveExpressionCode(
-                code,
-                readObject(unwrappedExpression.left),
-                context,
-              ),
+              code: conditionValueName,
             },
           ],
           whenFalse: rightBranch,
@@ -613,7 +624,11 @@ function analyzeOxcListExpression(
   const itemName = String(readObject(readArray(renderer.params)[0]).name ?? "_item");
   const indexName = readObject(readArray(renderer.params)[1]).name;
   const arrayName = readObject(readArray(renderer.params)[2]).name;
-  const rendererBody = analyzeOxcListRenderer(code, renderer, context, bodyStatementJsx);
+  const rendererContext = shadowOxcReactiveAliases(
+    context,
+    [itemName, indexName, arrayName].filter((name): name is string => typeof name === "string"),
+  );
+  const rendererBody = analyzeOxcListRenderer(code, renderer, rendererContext, bodyStatementJsx);
 
   if (rendererBody === undefined) {
     return undefined;
@@ -802,6 +817,36 @@ function resolveOxcBodyStatementJsx(context: OxcChildAnalysisContext): OxcBodySt
   return context.bodyStatementJsx ?? (context.target === "server" ? "server-string" : "dom-node");
 }
 
+function logicalConditionValueName(expression: Record<string, unknown>): string {
+  return `__mreactLogical_${typeof expression.start === "number" ? expression.start : "value"}`;
+}
+
+function renderableFalsyConditionValueCode(name: string): string {
+  return `((typeof ${name} === "number" || typeof ${name} === "bigint") ? ${name} : null)`;
+}
+
+function shadowOxcReactiveAliases(
+  context: OxcChildAnalysisContext,
+  names: readonly string[],
+): OxcChildAnalysisContext {
+  if (context.reactiveAliasBindings === undefined || names.length === 0) {
+    return context;
+  }
+
+  let aliases: Map<string, string> | undefined;
+
+  for (const name of names) {
+    if (!context.reactiveAliasBindings.has(name)) {
+      continue;
+    }
+
+    aliases ??= new Map(context.reactiveAliasBindings);
+    aliases.delete(name);
+  }
+
+  return aliases === undefined ? context : { ...context, reactiveAliasBindings: aliases };
+}
+
 function isOxcJsxCommentExpression(code: string, expression: Record<string, unknown>): boolean {
   if (typeof expression.start !== "number" || typeof expression.end !== "number") {
     return false;

package/src/oxc-component-detection.ts

@@ -34,6 +34,44 @@ export function collectOxcPlainComponentNames(program: unknown): string[] {
   });
 }
 
+export function collectOxcLocalJsxReturnFunctionNames(program: unknown): Set<string> {
+  const names = new Set<string>();
+
+  for (const statement of readArray(readObject(program).body)) {
+    const object = readObject(statement);
+
+    if (object.type === "FunctionDeclaration" && hasOxcFunctionLikeJsxReturn(object)) {
+      const id = readObject(object.id);
+      if (typeof id.name === "string") {
+        names.add(id.name);
+      }
+      continue;
+    }
+
+    if (object.type !== "VariableDeclaration") {
+      continue;
+    }
+
+    for (const declarator of readArray(object.declarations)) {
+      const declaratorObject = readObject(declarator);
+      const id = readObject(declaratorObject.id);
+      const initializer = unwrapOxcComponentFunctionLikeInitializer(
+        readObject(declaratorObject.init),
+      );
+
+      if (
+        typeof id.name === "string" &&
+        initializer !== undefined &&
+        hasOxcFunctionLikeJsxReturn(initializer)
+      ) {
+        names.add(id.name);
+      }
+    }
+  }
+
+  return names;
+}
+
 export function collectOxcExportedComponents(program: unknown): string[] {
   const body = readArray(readObject(program).body);
   const components: string[] = [];
@@ -133,8 +171,15 @@ export function isOxcExportedJsxComponent(statement: unknown): boolean {
   );
 }
 
-export function isOxcJsxComponentStatement(statement: unknown): boolean {
-  return isOxcExportedJsxComponent(statement) || readOxcPlainComponent(statement) !== undefined;
+export function isOxcJsxComponentStatement(
+  statement: unknown,
+  localJsxReturnFunctionNames: ReadonlySet<string> = new Set(),
+): boolean {
+  return (
+    isOxcExportedJsxComponent(statement) ||
+    isOxcExportedFunctionReturningLocalJsxHelper(statement, localJsxReturnFunctionNames) ||
+    readOxcPlainComponent(statement) !== undefined
+  );
 }
 
 export function isOxcExportedFunctionLike(statement: unknown): boolean {
@@ -159,6 +204,7 @@ export function isOxcExportedFunctionLike(statement: unknown): boolean {
 export function isOxcUnsupportedExportedFunction(
   statement: unknown,
   options?: AnalyzeModuleOptions,
+  localJsxReturnFunctionNames: ReadonlySet<string> = new Set(),
 ): boolean {
   if (options?.compatReactNodeReturn === true) {
     return false;
@@ -178,10 +224,29 @@ export function isOxcUnsupportedExportedFunction(
     typeof id.name === "string" &&
     /^[A-Z]/.test(id.name) &&
     !hasComponentReturn(declaration.body) &&
+    !hasLocalJsxHelperCallReturn(declaration.body, localJsxReturnFunctionNames) &&
     !hasOnlyNullReturns(declaration.body)
   );
 }
 
+function isOxcExportedFunctionReturningLocalJsxHelper(
+  statement: unknown,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  const object = readObject(statement);
+
+  if (object.type !== "ExportNamedDeclaration") {
+    return false;
+  }
+
+  const declaration = readObject(object.declaration);
+
+  return (
+    declaration.type === "FunctionDeclaration" &&
+    hasLocalJsxHelperCallReturn(declaration.body, localJsxReturnFunctionNames)
+  );
+}
+
 export function readOxcVariableComponentDeclaration(
   declaration: Record<string, unknown>,
 ): { name: string; initializer: Record<string, unknown> } | undefined {
@@ -305,6 +370,45 @@ export function hasComponentCallReturn(body: unknown): boolean {
   });
 }
 
+export function hasLocalJsxHelperCallReturn(
+  body: unknown,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  if (localJsxReturnFunctionNames.size === 0) {
+    return false;
+  }
+
+  return readArray(readObject(body).body).some((statement) => {
+    const object = readObject(statement);
+
+    if (object.type === "ReturnStatement") {
+      return isOxcLocalJsxHelperCallExpression(
+        unwrapOxcParentheses(readObject(object.argument)),
+        localJsxReturnFunctionNames,
+      );
+    }
+
+    return hasNestedLocalJsxHelperCallReturn(object, localJsxReturnFunctionNames);
+  });
+}
+
+export function isOxcLocalJsxHelperCallExpression(
+  expression: Record<string, unknown>,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  if (expression.type !== "CallExpression") {
+    return false;
+  }
+
+  const callee = unwrapOxcParentheses(readObject(expression.callee));
+
+  return (
+    callee.type === "Identifier" &&
+    typeof callee.name === "string" &&
+    localJsxReturnFunctionNames.has(callee.name)
+  );
+}
+
 function hasNestedJsxReturn(statement: Record<string, unknown>): boolean {
   if (statement.type === "SwitchStatement") {
     return readArray(statement.cases).some((switchCase) =>
@@ -359,6 +463,45 @@ function hasNestedComponentCallReturn(statement: Record<string, unknown>): boole
   return false;
 }
 
+function hasNestedLocalJsxHelperCallReturn(
+  statement: Record<string, unknown>,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  if (statement.type === "SwitchStatement") {
+    return readArray(statement.cases).some((switchCase) =>
+      readArray(readObject(switchCase).consequent).some((child) => {
+        const object = readObject(child);
+        return (
+          object.type === "ReturnStatement" &&
+          isOxcLocalJsxHelperCallExpression(
+            unwrapOxcParentheses(readObject(object.argument)),
+            localJsxReturnFunctionNames,
+          )
+        );
+      }),
+    );
+  }
+
+  if (statement.type === "IfStatement") {
+    return (
+      hasLocalJsxHelperCallReturn(
+        { body: [statement.consequent] },
+        localJsxReturnFunctionNames,
+      ) ||
+      hasLocalJsxHelperCallReturn(
+        { body: [statement.alternate] },
+        localJsxReturnFunctionNames,
+      )
+    );
+  }
+
+  if (statement.type === "BlockStatement") {
+    return hasLocalJsxHelperCallReturn(statement, localJsxReturnFunctionNames);
+  }
+
+  return false;
+}
+
 function collectReturnArguments(statement: Record<string, unknown>): Record<string, unknown>[] {
   if (statement.type === "ReturnStatement") {
     return [readObject(statement.argument)];

package/src/oxc-component-props.ts

@@ -16,6 +16,7 @@ import type { Diagnostic } from "./types.js";
 export type AnalyzeOxcJsxNodeCallback = (
   node: Record<string, unknown>,
   bodyStatementJsx?: OxcBodyStatementJsxMode,
+  shadowNames?: readonly string[],
 ) => JsxNodeIr;
 
 export function analyzeOxcComponentProp(
@@ -159,7 +160,7 @@ export function analyzeOxcArrowJsxRenderer(
   if (body.type === "JSXElement" || body.type === "JSXFragment") {
     return {
       valueName,
-      children: [analyzeJsxNode(body, bodyStatementJsx)],
+      children: [analyzeJsxNode(body, bodyStatementJsx, [valueName])],
     };
   }
 

package/src/oxc-component-references.ts

@@ -1,8 +1,8 @@
 import type { ClientReferenceIr, JsxNodeIr } from "./ir.js";
 import { readArray, readObject } from "./oxc-node-utils.js";
 
-const routerEntryCompatRuntimeExports = new Set(["Link"]);
-const routerLinkCompatRuntimeExports = new Set(["Link"]);
+const routerEntryCompatRuntimeExports = new Set<string>();
+const routerLinkCompatRuntimeExports = new Set<string>();
 const unknownCompatReference: ClientReferenceIr = { moduleId: "", exportName: "default" };
 
 interface ClientReferenceAliasState {

package/src/oxc-runtime-emit.ts

@@ -22,7 +22,12 @@ function emitOxcServerStringNode(node: JsxNodeIr): string {
   }
 
   if (node.kind === "conditional") {
-    return `((${node.conditionCode}) ? ${emitOxcServerStringChildren(node.whenTrue)} : ${emitOxcServerStringChildren(node.whenFalse)})`;
+    const whenTrue = emitOxcServerStringChildren(node.whenTrue);
+    const whenFalse = emitOxcServerStringChildren(node.whenFalse);
+
+    return node.conditionValueName === undefined
+      ? `((${node.conditionCode}) ? ${whenTrue} : ${whenFalse})`
+      : `(() => { const ${node.conditionValueName} = (${node.conditionCode}); return ${node.conditionValueName} ? ${whenTrue} : ${whenFalse}; })()`;
   }
 
   if (node.kind === "list") {
@@ -99,7 +104,12 @@ function emitOxcCompatObjectNode(node: JsxNodeIr): string {
   }
 
   if (node.kind === "conditional") {
-    return `(${node.conditionCode}) ? ${emitOxcCompatObjectChildren(node.whenTrue)} : ${emitOxcCompatObjectChildren(node.whenFalse)}`;
+    const whenTrue = emitOxcCompatObjectChildren(node.whenTrue);
+    const whenFalse = emitOxcCompatObjectChildren(node.whenFalse);
+
+    return node.conditionValueName === undefined
+      ? `(${node.conditionCode}) ? ${whenTrue} : ${whenFalse}`
+      : `(() => { const ${node.conditionValueName} = (${node.conditionCode}); return ${node.conditionValueName} ? ${whenTrue} : ${whenFalse}; })()`;
   }
 
   if (node.kind === "list") {

package/src/oxc.ts

@@ -43,11 +43,14 @@ import {
   collectOxcAsyncComponentNames,
   collectOxcExportedComponents,
   collectOxcExportedFunctionNames,
+  collectOxcLocalJsxReturnFunctionNames,
   collectOxcPlainComponentNames,
   hasComponentReturn,
+  hasLocalJsxHelperCallReturn,
   hasOxcFunctionLikeComponentReturn,
   isOxcExportedFunctionLike,
   isOxcComponentCallExpression,
+  isOxcLocalJsxHelperCallExpression,
   isJsxRoot,
   isOxcJsxComponentStatement,
   isOxcUnsupportedExportedFunction,
@@ -242,6 +245,12 @@ function analyzeOxcToIr(
     options?.compatReactNodeReturnRenderMode === "react-node"
       ? collectOxcCompatReactNodeComponentReferences(program)
       : undefined;
+  const localJsxReturnFunctionNames =
+    target === "server" ? collectOxcLocalJsxReturnFunctionNames(program) : new Set<string>();
+  const localJsxHelperHtmlParameters =
+    target === "server"
+      ? collectLocalJsxHelperHtmlParameters(program, localJsxReturnFunctionNames)
+      : new Map<string, Set<number>>();
   const bodyLowerers = createOxcBodyLowerers(compatRuntimeImports);
   const moduleRenderValueBindings = collectOxcBodyJsxBindingNames(body);
   const reactiveDerivedFunctionNames = collectOxcReactiveDerivedFunctionNames(body);
@@ -263,7 +272,7 @@ function analyzeOxcToIr(
     }
 
     if (
-      isOxcJsxComponentStatement(statement) ||
+      isOxcJsxComponentStatement(statement, localJsxReturnFunctionNames) ||
       (options?.compatReactNodeReturn === true && isOxcExportedFunctionLike(statement))
     ) {
       const declaration = readObject(readObject(statement).declaration);
@@ -275,7 +284,7 @@ function analyzeOxcToIr(
       }
       continue;
     } else {
-      if (isOxcUnsupportedExportedFunction(statement, options)) {
+      if (isOxcUnsupportedExportedFunction(statement, options, localJsxReturnFunctionNames)) {
         diagnostics.push({
           level: "error",
           code: "MR_UNSUPPORTED_COMPONENT_RETURN",
@@ -333,6 +342,8 @@ function analyzeOxcToIr(
       componentCallNames,
       bodyLowerers,
       reactiveDerivedFunctionNames,
+      localJsxReturnFunctionNames,
+      localJsxHelperHtmlParameters,
     ),
   );
 
@@ -387,6 +398,88 @@ function componentCallNamesFromProgram(program: unknown): Set<string> {
   ]);
 }
 
+function collectLocalJsxHelperHtmlParameters(
+  program: unknown,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): Map<string, Set<number>> {
+  const parameters = new Map<string, Set<number>>();
+
+  if (localJsxReturnFunctionNames.size === 0) {
+    return parameters;
+  }
+
+  for (const statement of readArray(readObject(program).body)) {
+    const object = readObject(statement);
+    const declaration =
+      object.type === "ExportNamedDeclaration" || object.type === "ExportDefaultDeclaration"
+        ? readObject(object.declaration)
+        : object;
+    const body = readObject(declaration.body);
+
+    if (body.type !== "BlockStatement") {
+      continue;
+    }
+
+    for (const returnExpression of collectOxcReturnExpressions(body)) {
+      const callExpression = unwrapOxcParentheses(returnExpression);
+      if (callExpression.type !== "CallExpression") {
+        continue;
+      }
+
+      const callee = unwrapOxcParentheses(readObject(callExpression.callee));
+      if (
+        callee.type !== "Identifier" ||
+        typeof callee.name !== "string" ||
+        !localJsxReturnFunctionNames.has(callee.name)
+      ) {
+        continue;
+      }
+      const calleeName = callee.name;
+
+      readArray(callExpression.arguments).forEach((argument, index) => {
+        if (!containsOxcJsxSyntax(readObject(argument))) {
+          return;
+        }
+
+        const indexes = parameters.get(calleeName) ?? new Set<number>();
+        indexes.add(index);
+        parameters.set(calleeName, indexes);
+      });
+    }
+  }
+
+  return parameters;
+}
+
+function collectOxcReturnExpressions(statement: Record<string, unknown>): Record<string, unknown>[] {
+  if (statement.type === "ReturnStatement") {
+    return [unwrapOxcParentheses(readObject(statement.argument))];
+  }
+
+  if (statement.type === "BlockStatement") {
+    return readArray(statement.body).flatMap((child) =>
+      collectOxcReturnExpressions(readObject(child)),
+    );
+  }
+
+  if (statement.type === "IfStatement") {
+    return [
+      ...collectOxcReturnExpressions(readObject(statement.consequent)),
+      ...collectOxcReturnExpressions(readObject(statement.alternate)),
+    ];
+  }
+
+  if (statement.type === "SwitchStatement") {
+    return readArray(statement.cases).flatMap((switchCase) =>
+      readArray(readObject(switchCase).consequent).flatMap((child) =>
+        collectOxcReturnExpressions(readObject(child)),
+      ),
+    );
+  }
+
+  return [];
+}
+
 function analyzeOxcComponent(
   code: string,
   statement: unknown,
@@ -400,6 +493,8 @@ function analyzeOxcComponent(
   componentCallNames: Set<string> | undefined,
   bodyLowerers: OxcBodyLowerers,
   reactiveDerivedFunctionNames: ReadonlySet<string>,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+  localJsxHelperHtmlParameters: ReadonlyMap<string, ReadonlySet<number>>,
 ): ComponentIr[] {
   const object = readObject(statement);
 
@@ -428,6 +523,8 @@ function analyzeOxcComponent(
         componentCallNames,
         bodyLowerers,
         reactiveDerivedFunctionNames,
+        localJsxReturnFunctionNames,
+        localJsxHelperHtmlParameters,
         true,
       ),
     ];
@@ -457,6 +554,8 @@ function analyzeOxcComponent(
           componentCallNames,
           bodyLowerers,
           reactiveDerivedFunctionNames,
+          localJsxReturnFunctionNames,
+          localJsxHelperHtmlParameters,
         ),
         exported: false,
       },
@@ -488,13 +587,17 @@ function analyzeOxcComponent(
         componentCallNames,
         bodyLowerers,
         reactiveDerivedFunctionNames,
+        localJsxReturnFunctionNames,
+        localJsxHelperHtmlParameters,
       ),
     ];
   }
 
   if (
     declaration.type !== "FunctionDeclaration" ||
-    (!compatReactNodeReturn && !hasComponentReturn(declaration.body))
+    (!compatReactNodeReturn &&
+      !hasComponentReturn(declaration.body) &&
+      !hasLocalJsxHelperCallReturn(declaration.body, localJsxReturnFunctionNames))
   ) {
     return [];
   }
@@ -521,10 +624,40 @@ function analyzeOxcComponent(
       componentCallNames,
       bodyLowerers,
       reactiveDerivedFunctionNames,
+      localJsxReturnFunctionNames,
+      localJsxHelperHtmlParameters,
     ),
   ];
 }
 
+function lowerOxcLocalJsxHelperCallExpressionCode(
+  code: string,
+  expression: Record<string, unknown>,
+  componentNames: Set<string>,
+  target: CompileTarget,
+  diagnostics: Diagnostic[],
+  bodyLowerers: OxcBodyLowerers,
+): string {
+  if (expression.type !== "CallExpression") {
+    return readSource(code, expression);
+  }
+
+  const args = readArray(expression.arguments).map((argument) => {
+    const object = unwrapOxcParentheses(readObject(argument));
+    return containsOxcJsxSyntax(object)
+      ? (bodyLowerers.lowerServerStringExpression(
+          code,
+          object,
+          componentNames,
+          target,
+          diagnostics,
+        ) ?? readSource(code, argument))
+      : readSource(code, argument);
+  });
+
+  return `${readSource(code, readObject(expression.callee))}(${args.join(", ")})`;
+}
+
 function analyzeOxcFunctionLikeComponent(
   code: string,
   name: string,
@@ -540,6 +673,8 @@ function analyzeOxcFunctionLikeComponent(
   componentCallNames: Set<string> | undefined,
   bodyLowerers: OxcBodyLowerers,
   reactiveDerivedFunctionNames: ReadonlySet<string>,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+  localJsxHelperHtmlParameters: ReadonlyMap<string, ReadonlySet<number>>,
   exportDefault = false,
 ): ComponentIr {
   const functionBody = readObject(functionLike.body);
@@ -563,6 +698,15 @@ function analyzeOxcFunctionLikeComponent(
   const parameters = readArray(functionLike.params).map((param) =>
     readOxcParameterName(code, param),
   );
+  const htmlParameterNames = new Set(
+    [...(localJsxHelperHtmlParameters.get(name) ?? [])]
+      .map((index) => parameters[index])
+      .filter((parameter): parameter is string => parameter !== undefined),
+  );
+  const bodyComponentNames =
+    /^[a-z]/.test(name) && componentNames.has(name)
+      ? new Set([...componentNames].filter((componentName) => componentName !== name))
+      : componentNames;
   const bodyStatements = body
     .filter(
       (bodyStatement) =>
@@ -576,7 +720,7 @@ function analyzeOxcFunctionLikeComponent(
         lowerOxcBodyStatementJsx(
           code,
           bodyStatement,
-          componentNames,
+          bodyComponentNames,
           target,
           diagnostics,
           bodyStatementJsx,
@@ -590,7 +734,7 @@ function analyzeOxcFunctionLikeComponent(
     reactiveDerivedFunctionNames,
   );
   const childAnalysisContext = createOxcChildAnalysisContext(
-    componentNames,
+    bodyComponentNames,
     target,
     diagnostics,
     bodyStatementJsx,
@@ -617,6 +761,23 @@ function analyzeOxcFunctionLikeComponent(
       ? analyzeOxcJsxNode(code, returnExpression, childAnalysisContext)
       : isOxcComponentCallExpression(returnExpression)
         ? analyzeOxcComponentCallExpression(code, returnExpression)
+        : isOxcLocalJsxHelperCallExpression(returnExpression, localJsxReturnFunctionNames)
+          ? {
+              kind: "expr" as const,
+              code: normalizeOxcExpressionCode(
+                bodyStatementJsx === "server-string"
+                  ? lowerOxcLocalJsxHelperCallExpressionCode(
+                      code,
+                      returnExpression,
+                      bodyComponentNames,
+                      target,
+                      diagnostics,
+                      bodyLowerers,
+                    )
+                  : readSource(code, returnExpression),
+              ),
+              renderMode: "html" as const,
+            }
         : analyzeOxcDynamicRootReturn(
             code,
             returnExpression,
@@ -654,6 +815,7 @@ function analyzeOxcFunctionLikeComponent(
             bodyStatement !== earlyIfRootReturn?.fallthroughStatement,
         ),
       ),
+      ...htmlParameterNames,
     ]),
     bodyStatementJsx === "server-string" ? "html" : "dynamic",
   );