rwsdk 0.2.0-alpha.9 → 0.3.0

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -1,19 +1,16 @@
-import { Project, Node, SyntaxKind } from "ts-morph";
-import { readFile } from "node:fs/promises";
-import { pathExists } from "fs-extra";
+import { Project, Node, SyntaxKind, } from "ts-morph";
 import debug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:transform-jsx-script-tags");
-let manifestCache;
-const readManifest = async (manifestPath) => {
-    if (manifestCache === undefined) {
-        const exists = await pathExists(manifestPath);
-        if (!exists) {
-            throw new Error(`RedwoodSDK expected client manifest to exist at ${manifestPath}. This is likely a bug. Please report it at https://github.com/redwoodjs/sdk/issues/new`);
-        }
-        manifestCache = JSON.parse(await readFile(manifestPath, "utf-8"));
+function transformAssetPath(importPath, projectRootDir) {
+    if (process.env.VITE_IS_DEV_SERVER === "1") {
+        return importPath;
     }
-    return manifestCache;
-};
+    const normalizedImportPath = normalizeModulePath(importPath, projectRootDir);
+    return `rwsdk_asset:${normalizedImportPath}`;
+}
+// Note: This plugin only runs during discovery phase (Phase 1)
+// Manifest reading and asset linking happens later in Phase 5
 function hasJsxFunctions(text) {
     return (text.includes('jsx("script"') ||
         text.includes("jsx('script'") ||
@@ -28,23 +25,18 @@ function hasJsxFunctions(text) {
         text.includes('jsxDEV("link"') ||
         text.includes("jsxDEV('link'"));
 }
-// Transform import statements in script content using ts-morph
-function transformScriptImports(scriptContent, manifest) {
+function transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir) {
     const scriptProject = new Project({ useInMemoryFileSystem: true });
     try {
-        // Wrap in a function to make it valid JavaScript
         const wrappedContent = `function __wrapper() {${scriptContent}}`;
         const scriptFile = scriptProject.createSourceFile("script.js", wrappedContent);
         let hasChanges = false;
         const entryPoints = [];
-        // Find all CallExpressions that look like import("path")
         scriptFile
             .getDescendantsOfKind(SyntaxKind.CallExpression)
             .forEach((callExpr) => {
             const expr = callExpr.getExpression();
-            // Check for both "import()" and "await import()" patterns
             const isImport = expr.getText() === "import";
-            // Check for await import pattern
             const isAwaitImport = expr.getKind() === SyntaxKind.PropertyAccessExpression &&
                 expr.getText().endsWith(".import");
             if (isImport || isAwaitImport) {
@@ -54,35 +46,29 @@ function transformScriptImports(scriptContent, manifest) {
                     if (importPath.startsWith("/")) {
                         log("Found dynamic import with root-relative path: %s", importPath);
                         entryPoints.push(importPath);
-                        const path = importPath.slice(1); // Remove leading slash
-                        if (manifest[path]) {
-                            const transformedSrc = `/${manifest[path].file}`;
-                            args[0].setLiteralValue(transformedSrc);
-                            hasChanges = true;
-                        }
+                        clientEntryPoints.add(importPath);
+                        const transformedImportPath = transformAssetPath(importPath, projectRootDir);
+                        args[0].setLiteralValue(transformedImportPath);
+                        hasChanges = true;
                     }
                 }
             }
         });
         if (hasChanges) {
-            // Extract the transformed content from inside the wrapper function
             const fullText = scriptFile.getFullText();
-            // Find content between the first { and the last }
             const startPos = fullText.indexOf("{") + 1;
             const endPos = fullText.lastIndexOf("}");
             const transformedContent = fullText.substring(startPos, endPos);
             return { content: transformedContent, hasChanges: true, entryPoints };
         }
-        // Return the original content when no changes are made
         return { content: scriptContent, hasChanges: false, entryPoints };
     }
     catch (error) {
-        // If parsing fails, fall back to the original content
         console.warn("Failed to parse inline script content:", error);
         return { content: undefined, hasChanges: false, entryPoints: [] };
     }
 }
-export async function transformJsxScriptTagsCode(code, manifest = {}) {
+export async function transformJsxScriptTagsCode(code, clientEntryPoints, manifest = {}, projectRootDir) {
     // context(justinvdm, 15 Jun 2025): Optimization to exit early
     // to avoidunnecessary ts-morph parsing
     if (!hasJsxFunctions(code)) {
@@ -90,17 +76,15 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
     }
     const project = new Project({ useInMemoryFileSystem: true });
     const sourceFile = project.createSourceFile("temp.tsx", code);
-    let hasModifications = false;
+    const modifications = [];
     const needsRequestInfoImportRef = { value: false };
-    // Check for existing imports up front
+    const entryPointsPerCallExpr = new Map();
     let hasRequestInfoImport = false;
     let sdkWorkerImportDecl;
-    // Scan for imports only once
     sourceFile.getImportDeclarations().forEach((importDecl) => {
         const moduleSpecifier = importDecl.getModuleSpecifierValue();
         if (moduleSpecifier === "rwsdk/worker") {
             sdkWorkerImportDecl = importDecl;
-            // Check if requestInfo is already imported
             if (importDecl
                 .getNamedImports()
                 .some((namedImport) => namedImport.getName() === "requestInfo")) {
@@ -108,163 +92,128 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
             }
         }
     });
-    // Look for jsx function calls (jsx, jsxs, jsxDEV)
     sourceFile
         .getDescendantsOfKind(SyntaxKind.CallExpression)
         .forEach((callExpr) => {
         const expression = callExpr.getExpression();
         const expressionText = expression.getText();
-        // Only process jsx/jsxs/jsxDEV calls
         if (expressionText !== "jsx" &&
             expressionText !== "jsxs" &&
             expressionText !== "jsxDEV") {
             return;
         }
-        // Get arguments of the jsx call
         const args = callExpr.getArguments();
         if (args.length < 2)
             return;
-        // First argument should be the element type
         const elementType = args[0];
         if (!Node.isStringLiteral(elementType))
             return;
         const tagName = elementType.getLiteralValue();
         const entryPoints = [];
-        // Process script and link tags
         if (tagName === "script" || tagName === "link") {
-            // Second argument should be the props object
             const propsArg = args[1];
-            // Handle object literals with properties
             if (Node.isObjectLiteralExpression(propsArg)) {
                 const properties = propsArg.getProperties();
-                // Variables to track script attributes
                 let hasDangerouslySetInnerHTML = false;
                 let hasNonce = false;
                 let hasStringLiteralChildren = false;
                 let hasSrc = false;
-                // Variables to track link attributes
                 let isPreload = false;
-                let hrefValue = null;
+                let hrefProp;
                 for (const prop of properties) {
                     if (Node.isPropertyAssignment(prop)) {
                         const propName = prop.getName();
                         const initializer = prop.getInitializer();
-                        // Check for existing nonce
                         if (propName === "nonce") {
                             hasNonce = true;
                         }
-                        // Check for dangerouslySetInnerHTML
                         if (propName === "dangerouslySetInnerHTML") {
                             hasDangerouslySetInnerHTML = true;
                         }
-                        // Check for src attribute
                         if (tagName === "script" && propName === "src") {
                             hasSrc = true;
-                            // Also process src for manifest transformation if needed
                             if (Node.isStringLiteral(initializer) ||
                                 Node.isNoSubstitutionTemplateLiteral(initializer)) {
                                 const srcValue = initializer.getLiteralValue();
                                 if (srcValue.startsWith("/")) {
                                     entryPoints.push(srcValue);
-                                    const path = srcValue.slice(1); // Remove leading slash
-                                    if (manifest[path]) {
-                                        const transformedSrc = `/${manifest[path].file}`;
-                                        initializer.setLiteralValue(transformedSrc);
-                                        hasModifications = true;
-                                    }
+                                    clientEntryPoints.add(srcValue);
+                                    const transformedSrc = transformAssetPath(srcValue, projectRootDir);
+                                    modifications.push({
+                                        type: "literalValue",
+                                        node: initializer,
+                                        value: transformedSrc,
+                                    });
                                 }
                             }
                         }
-                        // Check for string literal children
                         if (tagName === "script" &&
                             propName === "children" &&
                             (Node.isStringLiteral(initializer) ||
                                 Node.isNoSubstitutionTemplateLiteral(initializer))) {
                             hasStringLiteralChildren = true;
                             const scriptContent = initializer.getLiteralValue();
-                            // Transform import statements in script content using ts-morph
-                            const { content: transformedContent, hasChanges: contentHasChanges, entryPoints: dynamicEntryPoints, } = transformScriptImports(scriptContent, manifest);
+                            const { content: transformedContent, hasChanges: contentHasChanges, entryPoints: dynamicEntryPoints, } = transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir);
                             entryPoints.push(...dynamicEntryPoints);
                             if (contentHasChanges && transformedContent) {
-                                // Get the raw text with quotes to determine the exact format
                                 const isTemplateLiteral = Node.isNoSubstitutionTemplateLiteral(initializer);
-                                if (isTemplateLiteral) {
-                                    // Simply wrap the transformed content in backticks
-                                    initializer.replaceWithText("`" + transformedContent + "`");
-                                }
-                                else {
-                                    initializer.replaceWithText(JSON.stringify(transformedContent));
-                                }
-                                hasModifications = true;
+                                const replacementText = isTemplateLiteral
+                                    ? "`" + transformedContent + "`"
+                                    : JSON.stringify(transformedContent);
+                                modifications.push({
+                                    type: "replaceText",
+                                    node: initializer,
+                                    text: replacementText,
+                                });
                             }
                         }
-                        // For link tags, first check if it's a preload/modulepreload
-                        if (tagName === "link") {
-                            if (propName === "rel" &&
-                                (Node.isStringLiteral(initializer) ||
-                                    Node.isNoSubstitutionTemplateLiteral(initializer))) {
-                                const relValue = initializer.getLiteralValue();
-                                if (relValue === "preload" || relValue === "modulepreload") {
-                                    isPreload = true;
-                                }
-                            }
-                            if (propName === "href" &&
-                                (Node.isStringLiteral(initializer) ||
-                                    Node.isNoSubstitutionTemplateLiteral(initializer))) {
-                                hrefValue = initializer.getLiteralValue();
+                        if (tagName === "link" &&
+                            propName === "rel" &&
+                            initializer &&
+                            (Node.isStringLiteral(initializer) ||
+                                Node.isNoSubstitutionTemplateLiteral(initializer))) {
+                            const relValue = initializer.getLiteralValue();
+                            if (relValue === "preload" || relValue === "modulepreload") {
+                                isPreload = true;
                             }
                         }
+                        if (tagName === "link" && propName === "href") {
+                            hrefProp = prop;
+                        }
+                    }
+                }
+                if (isPreload && hrefProp) {
+                    const initializer = hrefProp.getInitializer();
+                    if (initializer &&
+                        (Node.isStringLiteral(initializer) ||
+                            Node.isNoSubstitutionTemplateLiteral(initializer))) {
+                        const hrefValue = initializer.getLiteralValue();
+                        if (hrefValue.startsWith("/")) {
+                            const transformedHref = transformAssetPath(hrefValue, projectRootDir);
+                            modifications.push({
+                                type: "literalValue",
+                                node: initializer,
+                                value: transformedHref,
+                            });
+                        }
                     }
                 }
-                // Add nonce to script tags if needed
                 if (tagName === "script" &&
                     !hasNonce &&
                     !hasDangerouslySetInnerHTML &&
                     (hasStringLiteralChildren || hasSrc)) {
-                    // Add nonce property to the props object
-                    propsArg.addPropertyAssignment({
+                    modifications.push({
+                        type: "addProperty",
+                        node: propsArg,
                         name: "nonce",
                         initializer: "requestInfo.rw.nonce",
                     });
                     if (!hasRequestInfoImport) {
                         needsRequestInfoImportRef.value = true;
                     }
-                    hasModifications = true;
-                }
-                // Transform href if this is a preload link
-                if (tagName === "link" &&
-                    isPreload &&
-                    hrefValue &&
-                    hrefValue.startsWith("/") &&
-                    manifest[hrefValue.slice(1)]) {
-                    const path = hrefValue.slice(1); // Remove leading slash
-                    for (const prop of properties) {
-                        if (Node.isPropertyAssignment(prop) &&
-                            prop.getName() === "href") {
-                            const initializer = prop.getInitializer();
-                            if (Node.isStringLiteral(initializer) ||
-                                Node.isNoSubstitutionTemplateLiteral(initializer)) {
-                                const transformedHref = manifest[path].file;
-                                const originalText = initializer.getText();
-                                const isTemplateLiteral = Node.isNoSubstitutionTemplateLiteral(initializer);
-                                const quote = isTemplateLiteral
-                                    ? "`"
-                                    : originalText.charAt(0);
-                                // Preserve the original quote style
-                                if (isTemplateLiteral) {
-                                    initializer.replaceWithText(`\`/${transformedHref}\``);
-                                }
-                                else if (quote === '"') {
-                                    initializer.replaceWithText(`"/${transformedHref}"`);
-                                }
-                                else {
-                                    initializer.replaceWithText(`'/${transformedHref}'`);
-                                }
-                                hasModifications = true;
-                            }
-                        }
-                    }
                 }
+                // Note: Link preload href transformations happen in Phase 5 (Asset Linking)
+                // During discovery phase, we only transform script tags
             }
         }
         if (entryPoints.length > 0) {
@@ -274,51 +223,87 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
                 .join(",\n");
             const leadingCommentRanges = callExpr.getLeadingCommentRanges();
             const pureComment = leadingCommentRanges.find((r) => r.getText().includes("@__PURE__"));
-            const callExprText = callExpr.getText();
-            if (pureComment) {
-                const pureCommentText = pureComment.getText();
-                const newText = `(
-            ${sideEffects},
-            ${pureCommentText} ${callExprText}
-          )`;
-                const fullText = callExpr.getFullText();
-                const leadingTriviaText = fullText.substring(0, fullText.length - callExprText.length);
-                const newLeadingTriviaText = leadingTriviaText.replace(pureCommentText, "");
-                // By replacing from `getFullStart`, we remove the original node and all its leading trivia
-                // and replace it with our manually reconstructed string.
-                // This should correctly move the pure comment and preserve other comments and whitespace.
-                callExpr
-                    .getSourceFile()
-                    .replaceText([callExpr.getFullStart(), callExpr.getEnd()], newLeadingTriviaText + newText);
-            }
-            else {
-                callExpr.replaceWithText(`(
-              ${sideEffects},
-              ${callExprText}
-            )`);
+            const wrapInfo = {
+                callExpr: callExpr,
+                sideEffects: sideEffects,
+                pureCommentText: pureComment?.getText(),
+            };
+            if (!entryPointsPerCallExpr.has(callExpr)) {
+                entryPointsPerCallExpr.set(callExpr, wrapInfo);
             }
             needsRequestInfoImportRef.value = true;
-            hasModifications = true;
         }
     });
-    // Add requestInfo import if needed and not already imported
-    if (needsRequestInfoImportRef.value && hasModifications) {
-        if (sdkWorkerImportDecl) {
-            // Module is imported but need to add requestInfo
-            if (!hasRequestInfoImport) {
-                sdkWorkerImportDecl.addNamedImport("requestInfo");
+    if (modifications.length > 0 || entryPointsPerCallExpr.size > 0) {
+        for (const mod of modifications) {
+            if (mod.type === "literalValue") {
+                mod.node.setLiteralValue(mod.value);
+            }
+            else if (mod.type === "replaceText") {
+                mod.node.replaceWithText(mod.text);
+            }
+            else if (mod.type === "addProperty") {
+                mod.node.addPropertyAssignment({
+                    name: mod.name,
+                    initializer: mod.initializer,
+                });
             }
         }
-        else {
-            // Add new import declaration
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: "rwsdk/worker",
-                namedImports: ["requestInfo"],
+        const wrapModifications = [];
+        for (const [callExpr, wrapInfo] of entryPointsPerCallExpr) {
+            const fullStart = callExpr.getFullStart();
+            const end = callExpr.getEnd();
+            const callExprText = callExpr.getText();
+            const fullText = callExpr.getFullText();
+            const leadingWhitespace = fullText.substring(0, fullText.length - callExprText.length);
+            let pureCommentText;
+            let leadingTriviaText;
+            if (wrapInfo.pureCommentText) {
+                pureCommentText = wrapInfo.pureCommentText;
+                leadingTriviaText = leadingWhitespace;
+            }
+            wrapModifications.push({
+                type: "wrapCallExpr",
+                sideEffects: wrapInfo.sideEffects,
+                pureCommentText: pureCommentText,
+                leadingTriviaText: leadingTriviaText,
+                fullStart: fullStart,
+                end: end,
+                callExprText: callExprText,
+                leadingWhitespace: leadingWhitespace,
             });
         }
-    }
-    // Return the transformed code only if modifications were made
-    if (hasModifications) {
+        wrapModifications.sort((a, b) => b.fullStart - a.fullStart);
+        for (const mod of wrapModifications) {
+            if (mod.pureCommentText && mod.leadingTriviaText) {
+                const newText = `(
+${mod.sideEffects},
+${mod.pureCommentText} ${mod.callExprText}
+)`;
+                const newLeadingTriviaText = mod.leadingTriviaText.replace(mod.pureCommentText, "");
+                sourceFile.replaceText([mod.fullStart, mod.end], newLeadingTriviaText + newText);
+            }
+            else {
+                const leadingNewlines = mod.leadingWhitespace.match(/\n\s*/)?.[0] || "";
+                sourceFile.replaceText([mod.fullStart, mod.end], `${leadingNewlines}(
+${mod.sideEffects},
+${mod.callExprText}
+)`);
+            }
+        }
+        if (needsRequestInfoImportRef.value) {
+            if (sdkWorkerImportDecl) {
+                if (!hasRequestInfoImport) {
+                    sdkWorkerImportDecl.addNamedImport("requestInfo");
+                }
+            }
+            else {
+                sourceFile.addImportDeclaration({
+                    moduleSpecifier: "rwsdk/worker",
+                    namedImports: ["requestInfo"],
+                });
+            }
+        }
         return {
             code: sourceFile.getFullText(),
             map: null,
@@ -326,7 +311,7 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
     }
     return;
 }
-export const transformJsxScriptTagsPlugin = ({ manifestPath, }) => {
+export const transformJsxScriptTagsPlugin = ({ clientEntryPoints, projectRootDir, }) => {
     let isBuild = false;
     return {
         name: "rwsdk:vite:transform-jsx-script-tags",
@@ -334,12 +319,20 @@ export const transformJsxScriptTagsPlugin = ({ manifestPath, }) => {
             isBuild = config.command === "build";
         },
         async transform(code, id) {
+            if (isBuild &&
+                this.environment?.name === "worker" &&
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return null;
+            }
             if (this.environment?.name === "worker" &&
                 id.endsWith(".tsx") &&
                 !id.includes("node_modules") &&
                 hasJsxFunctions(code)) {
-                const manifest = isBuild ? await readManifest(manifestPath) : {};
-                const result = await transformJsxScriptTagsCode(code, manifest);
+                log("Transforming JSX script tags in %s", id);
+                process.env.VERBOSE && log("Code:\n%s", code);
+                // During discovery phase, never use manifest - it doesn't exist yet
+                const result = await transformJsxScriptTagsCode(code, clientEntryPoints, {}, // Empty manifest during discovery
+                projectRootDir);
                 if (result) {
                     log("Transformed JSX script tags in %s", id);
                     process.env.VERBOSE &&