@reckona/mreact-compiler 0.0.160 → 0.0.162

package/dist/oxc.js

@@ -13,7 +13,7 @@ import { collectOxcAsyncComponentNames, collectOxcExportedComponents, collectOxc
 import { collectOxcClientBoundaryImportComponents, collectOxcCompatReactNodeComponentReferences, collectOxcCompatRuntimeImportComponents, markOxcAsyncComponentReferences, markOxcClientReferences, markOxcCompatReactNodeReferences, markOxcCompatRuntimeReferences, } from "./oxc-component-references.js";
 import { normalizeOxcExpressionCode, stripOxcGeneratedImports } from "./oxc-code-utils.js";
 import { analyzeOxcExpressionChild, analyzeOxcJsxNode, } from "./oxc-child-analysis.js";
-import { analyzeCompatCreateElementRoot, collectCompatCreateElementNames, collectFunctionShadowedNames, hasLowerableCompatCreateElementReturn, } from "./oxc-compat-create-element.js";
+import { analyzeCompatCreateElementFunctionRoot, analyzeCompatCreateElementRoot, collectCompatCreateElementNames, collectCompatRenderToStringNames, collectFunctionShadowedNames, hasLowerableCompatCreateElementReturn, } from "./oxc-compat-create-element.js";
 import { lowerOxcDomNodeExpression } from "./oxc-dom-lowering.js";
 import { lowerOxcCompatObjectExpression, lowerOxcCompatReactNodeExpression, lowerOxcNestedJsxExpression, lowerOxcServerStringExpression, } from "./oxc-nested-lowering.js";
 import { isOxcJsxBranch, readOxcReturnExpressionFromStatement } from "./oxc-expression-utils.js";
@@ -41,6 +41,7 @@ function createOxcChildAnalysisContext(componentNames, target, diagnostics, body
         lowerNestedJsxExpression: lowerOxcNestedJsxExpression,
     };
 }
+/** Compares OXC component discovery and IR output against parity expectations for one module. */
 export function analyzeOxcParity(input) {
     const oxc = parseSync(input.filename, input.code, {
         lang: "tsx",
@@ -66,12 +67,14 @@ export function analyzeOxcParity(input) {
         },
     };
 }
+/** Analyzes source code into compiler IR using OXC parsing and lowering. */
 export function analyzeWithOxc(input) {
     return analyzeCompilerModuleContextWithOxc(createCompilerModuleContextWithOxc(input), {
         target: input.target,
         ...(input.options === undefined ? {} : { options: input.options }),
     });
 }
+/** Analyzes a cached OXC compiler module context into compiler IR. */
 export function analyzeCompilerModuleContextWithOxc(context, input) {
     const analyzed = analyzeOxcToIr(context.code, context.program, input.target, input.options);
     return {
@@ -108,10 +111,13 @@ function analyzeOxcToIr(code, program, target, options) {
         ? collectOxcCompatReactNodeComponentReferences(program)
         : undefined;
     const localJsxReturnFunctionNames = target === "server" ? collectOxcLocalJsxReturnFunctionNames(program) : new Set();
-    // Stream emit keeps interpreting compat trees for now; only the string
-    // pipeline lowers createElement calls.
-    const compatCreateElementNames = target === "server" && options?.serverOutput !== "stream"
-        ? collectCompatCreateElementNames(program)
+    const compatCreateElementNames = target === "server" ? collectCompatCreateElementNames(program) : new Set();
+    const compatRenderToStringNames = target === "server" ? collectCompatRenderToStringNames(program) : new Set();
+    const compatCreateElementLocalFunctionLikes = target === "server"
+        ? collectCompatCreateElementLocalFunctionLikes(program)
+        : new Map();
+    const compatRenderToStringLowerableTargets = target === "server"
+        ? collectCompatRenderToStringLowerableTargets(code, body, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes)
         : new Set();
     const localJsxHelperHtmlParameters = target === "server"
         ? collectLocalJsxHelperHtmlParameters(program, localJsxReturnFunctionNames)
@@ -133,7 +139,7 @@ function analyzeOxcToIr(code, program, target, options) {
             continue;
         }
         if (isOxcJsxComponentStatement(statement, localJsxReturnFunctionNames) ||
-            isCompatCreateElementComponentStatement(code, statement, compatCreateElementNames) ||
+            isCompatCreateElementComponentStatement(code, statement, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, compatRenderToStringLowerableTargets, options?.serverOutput) ||
             (options?.compatReactNodeReturn === true && isOxcExportedFunctionLike(statement))) {
             const declaration = readObject(readObject(statement).declaration);
             if (declaration.type === "VariableDeclaration") {
@@ -171,7 +177,7 @@ function analyzeOxcToIr(code, program, target, options) {
     const componentNames = componentNamesFromProgram(program, moduleBindingNames);
     const componentCallNames = options?.serverOutput === "stream" ? componentCallNamesFromProgram(program) : undefined;
     const asyncComponentNames = collectOxcAsyncComponentNames(program);
-    const components = body.flatMap((statement) => analyzeOxcComponent(code, statement, componentNames, target, diagnostics, options?.bodyStatementJsx ?? "dom-node", compatCreateElementNames, moduleRenderValueBindings, options?.compatReactNodeReturn === true, options?.serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters));
+    const components = body.flatMap((statement) => analyzeOxcComponent(code, statement, componentNames, target, diagnostics, options?.bodyStatementJsx ?? "dom-node", compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, compatRenderToStringLowerableTargets, moduleRenderValueBindings, options?.compatReactNodeReturn === true, options?.serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters));
     for (const component of components) {
         markOxcAsyncComponentReferences(component.root, asyncComponentNames);
         markOxcClientReferences(component.root, clientBoundaryImports);
@@ -302,47 +308,198 @@ function readCompatCreateElementPlainComponent(code, statement, names) {
     }
     return undefined;
 }
-function isCompatCreateElementComponentStatement(code, statement, names) {
-    if (names.size === 0) {
+function collectCompatCreateElementLocalFunctionLikes(program) {
+    const functionLikes = new Map();
+    for (const statement of readArray(readObject(program).body)) {
+        const object = readObject(statement);
+        const declaration = object.type === "ExportNamedDeclaration" ? readObject(object.declaration) : object;
+        if (declaration.type === "FunctionDeclaration") {
+            const id = readObject(declaration.id);
+            if (typeof id.name === "string") {
+                functionLikes.set(id.name, declaration);
+            }
+            continue;
+        }
+        if (declaration.type !== "VariableDeclaration") {
+            continue;
+        }
+        for (const declarator of readArray(declaration.declarations)) {
+            const declaratorObject = readObject(declarator);
+            const id = readObject(declaratorObject.id);
+            const initializer = unwrapOxcComponentFunctionLikeInitializer(readObject(declaratorObject.init));
+            if (typeof id.name === "string" && initializer !== undefined) {
+                functionLikes.set(id.name, initializer);
+            }
+        }
+    }
+    return functionLikes;
+}
+function collectCompatRenderToStringLowerableTargets(code, body, createElementNames, renderToStringNames, localFunctionLikes) {
+    const targets = new Set();
+    if (createElementNames.size === 0 || renderToStringNames.size === 0) {
+        return targets;
+    }
+    for (const statement of body) {
+        const functionLike = unwrapOxcStatementFunctionLike(statement);
+        if (functionLike === undefined) {
+            continue;
+        }
+        const targetName = readCompatRenderToStringWrapperTargetName(code, functionLike, renderToStringNames);
+        const targetFunctionLike = targetName === undefined ? undefined : localFunctionLikes.get(targetName);
+        if (targetName !== undefined &&
+            targetFunctionLike !== undefined &&
+            analyzeCompatCreateElementFunctionRoot(code, targetFunctionLike, createElementNames) !==
+                undefined) {
+            targets.add(targetName);
+        }
+    }
+    return targets;
+}
+function unwrapOxcStatementFunctionLike(statement) {
+    const object = readObject(statement);
+    const declaration = object.type === "ExportNamedDeclaration" || object.type === "ExportDefaultDeclaration"
+        ? readObject(object.declaration)
+        : object;
+    if (declaration.type === "FunctionDeclaration") {
+        return declaration;
+    }
+    if (declaration.type !== "VariableDeclaration") {
+        return unwrapOxcComponentFunctionLikeInitializer(declaration);
+    }
+    for (const declarator of readArray(declaration.declarations)) {
+        const initializer = unwrapOxcComponentFunctionLikeInitializer(readObject(readObject(declarator).init));
+        if (initializer !== undefined) {
+            return initializer;
+        }
+    }
+    return undefined;
+}
+function readCompatRenderToStringWrapperTargetName(code, functionLike, renderToStringNames) {
+    const expression = readCompatRenderToStringWrapperReturnExpression(functionLike);
+    if (expression === undefined) {
+        return undefined;
+    }
+    return readCompatRenderToStringTargetName(expression, renderToStringNames, collectFunctionShadowedNames(functionLike, renderToStringNames));
+}
+function readCompatRenderToStringWrapperReturnExpression(functionLike) {
+    const body = unwrapOxcParentheses(readObject(functionLike.body));
+    if (body.type !== "BlockStatement") {
+        return body;
+    }
+    for (const statement of readArray(body.body)) {
+        const statementObject = readObject(statement);
+        if (statementObject.type === "ReturnStatement") {
+            return unwrapOxcParentheses(readObject(statementObject.argument));
+        }
+    }
+    return undefined;
+}
+function readCompatRenderToStringTargetName(expression, renderToStringNames, shadowedNames) {
+    if (renderToStringNames.size === 0 ||
+        expression.type !== "CallExpression" ||
+        expression.optional === true) {
+        return undefined;
+    }
+    const callee = unwrapOxcParentheses(readObject(expression.callee));
+    if (callee.type !== "Identifier" ||
+        typeof callee.name !== "string" ||
+        !renderToStringNames.has(callee.name) ||
+        shadowedNames.has(callee.name)) {
+        return undefined;
+    }
+    const args = readArray(expression.arguments);
+    if (args.length !== 1) {
+        return undefined;
+    }
+    const target = unwrapOxcParentheses(readObject(args[0]));
+    return target.type === "Identifier" && typeof target.name === "string" ? target.name : undefined;
+}
+function hasCompatRenderToStringWrapperReturn(code, functionLike, renderToStringNames) {
+    return (readCompatRenderToStringWrapperTargetName(code, functionLike, renderToStringNames) !== undefined);
+}
+function analyzeCompatRenderToStringWrapperRoot(code, functionLike, returnExpression, createElementNames, renderToStringNames, localFunctionLikes) {
+    const targetName = readCompatRenderToStringTargetName(returnExpression, renderToStringNames, collectFunctionShadowedNames(functionLike, renderToStringNames));
+    if (targetName === undefined) {
+        return undefined;
+    }
+    const targetFunctionLike = localFunctionLikes.get(targetName);
+    const lowered = targetFunctionLike === undefined
+        ? undefined
+        : analyzeCompatCreateElementFunctionRoot(code, targetFunctionLike, createElementNames);
+    if (lowered !== undefined) {
+        return lowered;
+    }
+    return {
+        kind: "expr",
+        code: normalizeOxcExpressionCode(readSource(code, returnExpression)),
+        renderMode: "html",
+    };
+}
+function isCompatCreateElementComponentStatement(code, statement, names, renderToStringNames, localFunctionLikes, renderToStringLowerableTargets, serverOutput) {
+    if (names.size === 0 && renderToStringNames.size === 0) {
         return false;
     }
     const object = readObject(statement);
     if (object.type === "ExportDefaultDeclaration") {
-        return readCompatCreateElementFunctionLike(code, readObject(object.declaration), names) !== undefined;
+        const functionLike = unwrapOxcComponentFunctionLikeInitializer(readObject(object.declaration));
+        return (readCompatCreateElementFunctionLike(code, readObject(object.declaration), names) !==
+            undefined ||
+            (functionLike !== undefined &&
+                hasCompatRenderToStringWrapperReturn(code, functionLike, renderToStringNames)));
     }
     if (object.type === "ExportNamedDeclaration") {
         const declaration = readObject(object.declaration);
         if (declaration.type === "FunctionDeclaration") {
-            return hasLowerableCompatCreateElementReturn(code, declaration, names);
+            return (hasLowerableCompatCreateElementReturn(code, declaration, names) ||
+                hasCompatRenderToStringWrapperReturn(code, declaration, renderToStringNames));
         }
         return readCompatCreateElementPlainComponent(code, declaration, names) !== undefined;
     }
-    return readCompatCreateElementPlainComponent(code, statement, names) !== undefined;
+    const plainComponent = readCompatCreateElementPlainComponent(code, statement, names);
+    if (serverOutput === "stream") {
+        return (plainComponent !== undefined &&
+            renderToStringLowerableTargets.has(plainComponent.name) &&
+            localFunctionLikes.get(plainComponent.name) === plainComponent.initializer);
+    }
+    if (plainComponent !== undefined) {
+        return true;
+    }
+    const functionLike = unwrapOxcStatementFunctionLike(statement);
+    if (functionLike === undefined) {
+        return false;
+    }
+    return hasCompatRenderToStringWrapperReturn(code, functionLike, renderToStringNames);
 }
-function analyzeOxcComponent(code, statement, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters) {
+function analyzeOxcComponent(code, statement, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, compatRenderToStringLowerableTargets, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters) {
     const object = readObject(statement);
     if (object.type === "ExportDefaultDeclaration") {
         const declaration = unwrapOxcComponentFunctionLikeInitializer(readObject(object.declaration));
         if (declaration === undefined ||
             (!hasOxcFunctionLikeComponentReturn(declaration) &&
-                !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames))) {
+                !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames) &&
+                !hasCompatRenderToStringWrapperReturn(code, declaration, compatRenderToStringNames))) {
             return [];
         }
         const id = readObject(declaration.id);
         const name = typeof id.name === "string" ? id.name : "DefaultExport";
         return [
-            analyzeOxcFunctionLikeComponent(code, name, declaration, "default", componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters, true),
+            analyzeOxcFunctionLikeComponent(code, name, declaration, "default", componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters, true),
         ];
     }
     if (object.type !== "ExportNamedDeclaration") {
         const plainComponent = readOxcPlainComponent(statement) ??
-            readCompatCreateElementPlainComponent(code, statement, compatCreateElementNames);
+            (serverOutput === "stream"
+                ? undefined
+                : readCompatCreateElementPlainComponent(code, statement, compatCreateElementNames));
         if (plainComponent === undefined) {
             return [];
         }
+        if (compatRenderToStringLowerableTargets.has(plainComponent.name)) {
+            return [];
+        }
         return [
             {
-                ...analyzeOxcFunctionLikeComponent(code, plainComponent.name, plainComponent.initializer, plainComponent.name, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters),
+                ...analyzeOxcFunctionLikeComponent(code, plainComponent.name, plainComponent.initializer, plainComponent.name, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters),
                 exported: false,
             },
         ];
@@ -355,14 +512,15 @@ function analyzeOxcComponent(code, statement, componentNames, target, diagnostic
             return [];
         }
         return [
-            analyzeOxcFunctionLikeComponent(code, variableComponent.name, variableComponent.initializer, variableComponent.name, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters),
+            analyzeOxcFunctionLikeComponent(code, variableComponent.name, variableComponent.initializer, variableComponent.name, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters),
         ];
     }
     if (declaration.type !== "FunctionDeclaration" ||
         (!compatReactNodeReturn &&
             !hasComponentReturn(declaration.body) &&
             !hasLocalJsxHelperCallReturn(declaration.body, localJsxReturnFunctionNames) &&
-            !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames))) {
+            !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames) &&
+            !hasCompatRenderToStringWrapperReturn(code, declaration, compatRenderToStringNames))) {
         return [];
     }
     const id = readObject(declaration.id);
@@ -370,7 +528,7 @@ function analyzeOxcComponent(code, statement, componentNames, target, diagnostic
         return [];
     }
     return [
-        analyzeOxcFunctionLikeComponent(code, id.name, declaration, id.name, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters),
+        analyzeOxcFunctionLikeComponent(code, id.name, declaration, id.name, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters),
     ];
 }
 function lowerOxcLocalJsxHelperCallExpressionCode(code, expression, componentNames, target, diagnostics, bodyLowerers) {
@@ -385,7 +543,7 @@ function lowerOxcLocalJsxHelperCallExpressionCode(code, expression, componentNam
     });
     return `${readSource(code, readObject(expression.callee))}(${args.join(", ")})`;
 }
-function analyzeOxcFunctionLikeComponent(code, name, functionLike, exportName, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters, exportDefault = false) {
+function analyzeOxcFunctionLikeComponent(code, name, functionLike, exportName, componentNames, target, diagnostics, bodyStatementJsx, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes, moduleRenderValueBindings, compatReactNodeReturn, serverOutput, componentCallNames, bodyLowerers, reactiveDerivedFunctionNames, localJsxReturnFunctionNames, localJsxHelperHtmlParameters, exportDefault = false) {
     const functionBody = readObject(functionLike.body);
     const body = functionBody.type === "BlockStatement" ? readArray(functionBody.body) : [];
     const earlyIfRootReturn = bodyStatementJsx === "compat-object"
@@ -424,6 +582,7 @@ function analyzeOxcFunctionLikeComponent(code, name, functionLike, exportName, c
                 names: compatCreateElementNames,
                 shadowed: collectFunctionShadowedNames(functionLike, compatCreateElementNames),
             })) ??
+        analyzeCompatRenderToStringWrapperRoot(code, functionLike, returnExpression, compatCreateElementNames, compatRenderToStringNames, compatCreateElementLocalFunctionLikes) ??
         (isJsxRoot(returnExpression.type) || returnExpression.type === "JSXFragment"
             ? analyzeOxcJsxNode(code, returnExpression, childAnalysisContext)
             : isOxcComponentCallExpression(returnExpression)