rwsdk 0.1.16 → 0.1.17

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -0,0 +1,231 @@
+import MagicString from "magic-string";
+import path from "path";
+import { readFile } from "fs/promises";
+import debug from "debug";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { pathExists } from "fs-extra";
+import { stat } from "fs/promises";
+import { getSrcPaths } from "../lib/getSrcPaths.js";
+import { hasDirective } from "./hasDirective.mjs";
+export const findFilesContainingDirective = async ({ projectRootDir, files, directive, debugNamespace, }) => {
+    const log = debug(debugNamespace);
+    log("Starting search for '%s' files in projectRootDir=%s", directive, projectRootDir);
+    const filesToScan = await getSrcPaths(projectRootDir);
+    log("Found %d files to scan for '%s' directive", filesToScan.length, directive);
+    for (const file of filesToScan) {
+        try {
+            const stats = await stat(file);
+            if (!stats.isFile()) {
+                process.env.VERBOSE && log("Skipping %s (not a file)", file);
+                continue;
+            }
+            process.env.VERBOSE && log("Scanning file: %s", file);
+            const content = await readFile(file, "utf-8");
+            if (hasDirective(content, directive)) {
+                const normalizedPath = normalizeModulePath(projectRootDir, file);
+                log("Found '%s' directive in file: %s -> %s", directive, file, normalizedPath);
+                files.add(normalizedPath);
+            }
+        }
+        catch (error) {
+            console.error(`Error reading file ${file}:`, error);
+        }
+    }
+    log("Completed scan. Found %d %s files total", files.size, directive);
+    process.env.VERBOSE &&
+        log("Found files for %s: %j", directive, Array.from(files));
+};
+const resolveOptimizedDep = async (projectRootDir, id, environment, debugNamespace) => {
+    const log = debug(debugNamespace);
+    try {
+        const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
+        const nodeModulesDepsDirPath = path.join("node_modules", ".vite", depsDir);
+        const depsDirPath = path.join(projectRootDir, nodeModulesDepsDirPath);
+        const manifestPath = path.join(depsDirPath, "_metadata.json");
+        log("Checking for manifest at: %s", manifestPath);
+        const manifestExists = await pathExists(manifestPath);
+        if (!manifestExists) {
+            log("Manifest not found at %s", manifestPath);
+            return undefined;
+        }
+        const manifestContent = await readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(manifestContent);
+        if (manifest.optimized && manifest.optimized[id]) {
+            const optimizedFile = manifest.optimized[id].file;
+            const optimizedPath = path.join("/", nodeModulesDepsDirPath, optimizedFile);
+            log("Found optimized dependency: filePath=%s, optimizedPath=%s", id, optimizedPath);
+            return optimizedPath;
+        }
+        process.env.VERBOSE &&
+            log("File not found in optimized dependencies: id=%s", id);
+        return undefined;
+    }
+    catch (error) {
+        process.env.VERBOSE &&
+            log("Error resolving optimized dependency for id=%s: %s", id, error);
+        return undefined;
+    }
+};
+const addOptimizedDepsEntries = async ({ projectRootDir, directive, environment, debugNamespace, files, }) => {
+    const log = debug(debugNamespace);
+    try {
+        const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
+        const depsDirPath = path.join(projectRootDir, "node_modules", ".vite", depsDir);
+        const manifestPath = path.join(depsDirPath, "_metadata.json");
+        process.env.VERBOSE && log("Checking for manifest at: %s", manifestPath);
+        const manifestExists = await pathExists(manifestPath);
+        if (!manifestExists) {
+            process.env.VERBOSE && log("Manifest not found at %s", manifestPath);
+            return;
+        }
+        const manifestContent = await readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(manifestContent);
+        for (const entryId of Object.keys(manifest.optimized)) {
+            if (entryId.startsWith("/node_modules/")) {
+                const srcPath = manifest.optimized[entryId].src;
+                const resolvedSrcPath = path.resolve(projectRootDir, "node_modules", ".vite", "deps", srcPath);
+                let contents;
+                try {
+                    contents = await readFile(resolvedSrcPath, "utf-8");
+                }
+                catch (error) {
+                    process.env.VERBOSE &&
+                        log("Error reading file %s: %s", resolvedSrcPath, error);
+                    continue;
+                }
+                if (hasDirective(contents, directive)) {
+                    log("Adding optimized entry to files: %s", entryId);
+                    files.add(entryId);
+                }
+                else {
+                    log("Skipping optimized entry %s because it does not contain the '%s' directive", entryId, directive);
+                }
+            }
+        }
+    }
+    catch (error) {
+        process.env.VERBOSE &&
+            log("Error adding optimized deps entries: %s", error);
+    }
+};
+export const createDirectiveLookupPlugin = async ({ projectRootDir, files, config, }) => {
+    const debugNamespace = `rwsdk:vite:${config.pluginName}`;
+    const log = debug(debugNamespace);
+    let isDev = false;
+    log("Initializing %s plugin with projectRootDir=%s", config.pluginName, projectRootDir);
+    await findFilesContainingDirective({
+        projectRootDir,
+        files,
+        directive: config.directive,
+        debugNamespace,
+    });
+    let devServer;
+    return {
+        name: `rwsdk:${config.pluginName}`,
+        config(_, { command, isPreview }) {
+            isDev = !isPreview && command === "serve";
+            log("Development mode: %s", isDev);
+        },
+        configureServer(server) {
+            devServer = server;
+        },
+        async configEnvironment(env, viteConfig) {
+            log("Configuring environment: env=%s", env);
+            // Add optimized deps entries that match our pattern
+            await addOptimizedDepsEntries({
+                projectRootDir,
+                files,
+                directive: config.directive,
+                environment: env,
+                debugNamespace,
+            });
+            viteConfig.optimizeDeps ??= {};
+            viteConfig.optimizeDeps.esbuildOptions ??= {};
+            viteConfig.optimizeDeps.esbuildOptions.plugins ??= [];
+            viteConfig.optimizeDeps.esbuildOptions.plugins.push({
+                name: `rwsdk:${config.pluginName}`,
+                setup(build) {
+                    log("Setting up esbuild plugin for %s", config.virtualModuleName);
+                    // Handle both direct virtual module name and /@id/ prefixed version
+                    const escapedVirtualModuleName = config.virtualModuleName.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+                    const escapedPrefixedModuleName = `/@id/${config.virtualModuleName}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+                    build.onResolve({
+                        filter: new RegExp(`^(${escapedVirtualModuleName}|${escapedPrefixedModuleName})\.js$`),
+                    }, () => {
+                        process.env.VERBOSE &&
+                            log("Esbuild onResolve: marking %s as external", config.virtualModuleName);
+                        return {
+                            path: `${config.virtualModuleName}.js`,
+                            external: true,
+                        };
+                    });
+                },
+            });
+            const shouldOptimizeForEnv = !config.optimizeForEnvironments ||
+                config.optimizeForEnvironments.includes(env);
+            if (shouldOptimizeForEnv) {
+                log("Applying optimizeDeps and aliasing for environment: %s", env);
+                viteConfig.optimizeDeps.include ??= [];
+                for (const file of files) {
+                    const actualFilePath = path.join(projectRootDir, file);
+                    process.env.VERBOSE &&
+                        log("Adding to optimizeDeps.entries: %s", actualFilePath);
+                    const entries = Array.isArray(viteConfig.optimizeDeps.entries)
+                        ? viteConfig.optimizeDeps.entries
+                        : [].concat(viteConfig.optimizeDeps.entries ?? []);
+                    viteConfig.optimizeDeps.entries = entries;
+                    entries.push(actualFilePath);
+                }
+                log("Environment configuration complete for env=%s", env);
+            }
+            else {
+                log("Skipping optimizeDeps and aliasing for environment: %s", env);
+            }
+        },
+        resolveId(source) {
+            process.env.VERBOSE && log("Resolving id=%s", source);
+            if (source === `${config.virtualModuleName}.js`) {
+                log("Resolving %s module", config.virtualModuleName);
+                // context(justinvdm, 16 Jun 2025): Include .js extension
+                // so it goes through vite processing chain
+                return source;
+            }
+            process.env.VERBOSE && log("No resolution for id=%s", source);
+        },
+        async load(id) {
+            process.env.VERBOSE && log("Loading id=%s", id);
+            if (id === config.virtualModuleName + ".js") {
+                log("Loading %s module with %d files", config.virtualModuleName, files.size);
+                const environment = this.environment?.name || "client";
+                log("Current environment: %s, isDev: %s", environment, isDev);
+                const optimizedDeps = {};
+                if (isDev && devServer) {
+                    for (const file of files) {
+                        const resolvedPath = await resolveOptimizedDep(projectRootDir, file, environment, debugNamespace);
+                        if (resolvedPath) {
+                            optimizedDeps[file] = resolvedPath;
+                        }
+                    }
+                }
+                const s = new MagicString(`
+export const ${config.exportName} = {
+  ${Array.from(files)
+                    .map((file) => `
+  "${file}": () => import("${optimizedDeps[file] ?? file}"),
+`)
+                    .join("")}
+};
+`);
+                const code = s.toString();
+                const map = s.generateMap();
+                log("Generated virtual module code length: %d", code.length);
+                process.env.VERBOSE && log("Generated virtual module code: %s", code);
+                return {
+                    code,
+                    map,
+                };
+            }
+            process.env.VERBOSE && log("No load handling for id=%s", id);
+        },
+    };
+};

package/dist/vite/customReactBuildPlugin.d.mts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+export declare const customReactBuildPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Promise<Plugin>;

package/dist/vite/customReactBuildPlugin.mjs

@@ -0,0 +1,61 @@
+import { resolve } from "path";
+import { mkdirp, copy } from "fs-extra";
+import { VENDOR_DIST_DIR } from "../lib/constants.mjs";
+const copyReactFiles = async (viteDistDir) => {
+    await mkdirp(viteDistDir);
+    await copy(resolve(VENDOR_DIST_DIR, "react.js"), resolve(viteDistDir, "react.js"));
+    await copy(resolve(VENDOR_DIST_DIR, "react.js.map"), resolve(viteDistDir, "react.js.map"));
+    await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js"), resolve(viteDistDir, "react-dom-server-edge.js"));
+    await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js.map"), resolve(viteDistDir, "react-dom-server-edge.js.map"));
+};
+export const customReactBuildPlugin = async ({ projectRootDir, }) => {
+    const viteDistDir = resolve(projectRootDir, "node_modules", ".vite_@redwoodjs/sdk");
+    await copyReactFiles(viteDistDir);
+    return {
+        name: "custom-react-build-plugin",
+        enforce: "pre",
+        applyToEnvironment: (environment) => {
+            return environment.name === "worker";
+        },
+        async configureServer() {
+            await mkdirp(viteDistDir);
+            await copy(resolve(VENDOR_DIST_DIR, "react.js"), resolve(viteDistDir, "react.js"));
+            await copy(resolve(VENDOR_DIST_DIR, "react.js.map"), resolve(viteDistDir, "react.js.map"));
+            await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js"), resolve(viteDistDir, "react-dom-server-edge.js"));
+            await copy(resolve(VENDOR_DIST_DIR, "react-dom-server-edge.js.map"), resolve(viteDistDir, "react-dom-server-edge.js.map"));
+        },
+        resolveId(id) {
+            if (id === "react") {
+                return resolve(viteDistDir, "react.js");
+            }
+            if (id === "react-dom/server.edge" || id === "react-dom/server") {
+                return resolve(viteDistDir, "react-dom-server-edge.js");
+            }
+        },
+        config: () => ({
+            environments: {
+                worker: {
+                    optimizeDeps: {
+                        esbuildOptions: {
+                            plugins: [
+                                {
+                                    name: "rewrite-react-imports",
+                                    setup(build) {
+                                        build.onResolve({ filter: /^react$/ }, (args) => {
+                                            return { path: resolve(viteDistDir, "react.js") };
+                                        });
+                                        build.onResolve({ filter: /^react-dom\/server\.edge$/ }, (args) => {
+                                            return {
+                                                path: resolve(viteDistDir, "react-dom-server-edge.js"),
+                                            };
+                                        });
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+        }),
+    };
+};

package/dist/vite/devServerTimingPlugin.d.mts

@@ -0,0 +1,2 @@
+import { Plugin } from "vite";
+export declare const devServerTimingPlugin: () => Plugin;

package/dist/vite/devServerTimingPlugin.mjs

@@ -0,0 +1,24 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:dev-server-timing-plugin");
+export const devServerTimingPlugin = () => {
+    const startTime = Date.now();
+    let hasLoggedFirstResponse = false;
+    return {
+        name: "rwsdk:dev-server-timing",
+        configureServer(server) {
+            server.middlewares.use((_req, res, next) => {
+                if (!hasLoggedFirstResponse) {
+                    res.on("finish", () => {
+                        if (!hasLoggedFirstResponse) {
+                            hasLoggedFirstResponse = true;
+                            const endTime = Date.now();
+                            const duration = endTime - startTime;
+                            log(`🚀 Dev server first response completed in ${duration}ms`);
+                        }
+                    });
+                }
+                next();
+            });
+        },
+    };
+};

package/dist/vite/directivesPlugin.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+export declare const directivesPlugin: ({ projectRootDir, clientFiles, serverFiles, }: {
+    projectRootDir: string;
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
+}) => Plugin;

package/dist/vite/directivesPlugin.mjs

@@ -0,0 +1,200 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import debug from "debug";
+import { transformClientComponents } from "./transformClientComponents.mjs";
+import { transformServerFunctions } from "./transformServerFunctions.mjs";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:rsc-directives-plugin");
+const getLoader = (filePath) => {
+    const ext = path.extname(filePath).slice(1);
+    switch (ext) {
+        case "mjs":
+        case "cjs":
+            return "js";
+        case "mts":
+        case "cts":
+            return "ts";
+        case "jsx":
+            return "jsx";
+        case "tsx":
+            return "tsx";
+        case "ts":
+            return "ts";
+        case "js":
+        default:
+            return "js";
+    }
+};
+export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, }) => {
+    let devServer;
+    let isAfterFirstResponse = false;
+    const addModule = (kind, environment, id) => {
+        const files = kind === "client" ? clientFiles : serverFiles;
+        const rawId = id.split("?")[0];
+        const resolvedId = rawId;
+        const relativePath = rawId.slice("/".length);
+        const fullPath = path.resolve(projectRootDir, relativePath);
+        const isNodeModule = id.includes("node_modules");
+        const hadFile = files.has(id);
+        log("Adding %s module to %s and invalidating cache: id=%s", kind, files, resolvedId);
+        files.add(resolvedId);
+        if (devServer && isNodeModule) {
+            const lookupModule = kind === "client"
+                ? "virtual:use-client-lookup"
+                : "virtual:use-server-lookup";
+            log("Registering missing import for %s module resolvedId=%s in environment %s, fullPath=%s", kind, resolvedId, environment, fullPath);
+            devServer.environments[environment].depsOptimizer?.registerMissingImport(resolvedId, fullPath);
+            if (isAfterFirstResponse && !hadFile) {
+                log("Invalidating cache for lookup module %s after adding module id=%s", lookupModule, id);
+            }
+        }
+    };
+    const addClientModule = (environment, id) => {
+        addModule("client", environment, id);
+    };
+    const addServerModule = (environment, id) => {
+        addModule("server", environment, id);
+    };
+    return {
+        name: "rwsdk:rsc-directives",
+        configureServer(server) {
+            devServer = server;
+            devServer.middlewares.use((_req, res, next) => {
+                // context(justinvdm, 15 Jun 2025): We want to watch for new client and server modules
+                // and invalidate their respective module lookups when this happens, but
+                // we only want to do this after the first render
+                if (!isAfterFirstResponse) {
+                    res.on("finish", () => {
+                        if (!isAfterFirstResponse) {
+                            isAfterFirstResponse = true;
+                            log("Dev server first response completed");
+                        }
+                    });
+                }
+                next();
+            });
+        },
+        async transform(code, id) {
+            process.env.VERBOSE &&
+                log("Transform called for id=%s, environment=%s", id, this.environment.name);
+            const normalizedId = normalizeModulePath(projectRootDir, id);
+            const clientResult = await transformClientComponents(code, normalizedId, {
+                environmentName: this.environment.name,
+                clientFiles,
+                addClientModule,
+            });
+            if (clientResult) {
+                log("Client component transformation successful for id=%s", id);
+                return {
+                    code: clientResult.code,
+                    map: clientResult.map,
+                };
+            }
+            const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles, addServerModule);
+            if (serverResult) {
+                log("Server function transformation successful for id=%s", id);
+                return {
+                    code: serverResult.code,
+                    map: serverResult.map,
+                };
+            }
+            process.env.VERBOSE && log("No transformation applied for id=%s", id);
+        },
+        configEnvironment(env, config) {
+            log("Configuring environment: env=%s", env);
+            config.optimizeDeps ??= {};
+            config.optimizeDeps.esbuildOptions ??= {};
+            config.optimizeDeps.esbuildOptions.plugins ??= [];
+            config.optimizeDeps.esbuildOptions.plugins.push({
+                name: "rsc-directives-esbuild-transform",
+                setup(build) {
+                    log("Setting up esbuild plugin for environment: %s", env);
+                    build.onLoad({ filter: /\.(js|ts|jsx|tsx|mts|mjs|cjs)$/ }, async (args) => {
+                        process.env.VERBOSE &&
+                            log("Esbuild onLoad called for environment=%s, path=%s", env, args.path);
+                        const normalizedPath = normalizeModulePath(projectRootDir, args.path);
+                        // context(justinvdm,2025-06-15): If we're in app code,
+                        // we will be doing the transform work in the vite plugin hooks,
+                        // the only reason we're in esbuild land for app code is for
+                        // dependency discovery, so we can skip transform work
+                        // and use heuristics instead - see below inside if block
+                        if (!args.path.includes("node_modules")) {
+                            log("Esbuild onLoad found app code, path=%s", args.path);
+                            if (clientFiles.has(normalizedPath)) {
+                                // context(justinvdm,2025-06-15): If this is a client file:
+                                // * for ssr and client envs we can skip so esbuild looks at the
+                                // original source code to discovery dependencies
+                                // * for worker env, the transform would have just created
+                                // references and dropped all imports, so we can just return empty code
+                                if (env === "client" || env === "ssr") {
+                                    log("Esbuild onLoad skipping client module in app code for client or ssr env, path=%s", args.path);
+                                    return undefined;
+                                }
+                                else {
+                                    log("Esbuild onLoad returning empty code for server module in app code for worker env, path=%s to bypass esbuild dependency discovery", args.path);
+                                    return {
+                                        contents: "",
+                                        loader: "js",
+                                    };
+                                }
+                            }
+                            else if (serverFiles.has(normalizedPath)) {
+                                // context(justinvdm,2025-06-15): If this is a server file:
+                                // * for worker env, we can skip so esbuild looks at the
+                                // original source code to discovery dependencies
+                                // * for ssr and client envs, the transform would have just created
+                                // references and dropped all imports, so we can just return empty code
+                                if (env === "worker") {
+                                    log("Esbuild onLoad skipping server module in app code for worker env, path=%s", args.path);
+                                    return undefined;
+                                }
+                                else if (env === "ssr" || env === "client") {
+                                    log("Esbuild onLoad returning empty code for server module in app code for ssr or client env, path=%s", args.path);
+                                    return {
+                                        contents: "",
+                                        loader: "js",
+                                    };
+                                }
+                            }
+                        }
+                        let code;
+                        try {
+                            code = await fs.readFile(args.path, "utf-8");
+                        }
+                        catch {
+                            process.env.VERBOSE &&
+                                log("Failed to read file: %s, environment=%s", args.path, env);
+                            return undefined;
+                        }
+                        const clientResult = await transformClientComponents(code, normalizedPath, {
+                            environmentName: env,
+                            clientFiles,
+                            isEsbuild: true,
+                            addClientModule,
+                        });
+                        if (clientResult) {
+                            log("Esbuild client component transformation successful for environment=%s, path=%s", env, args.path);
+                            process.env.VERBOSE &&
+                                log("Esbuild client component transformation for environment=%s, path=%s, code: %j", env, args.path, clientResult.code);
+                            return {
+                                contents: clientResult.code,
+                                loader: getLoader(args.path),
+                            };
+                        }
+                        const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles, addServerModule);
+                        if (serverResult) {
+                            log("Esbuild server function transformation successful for environment=%s, path=%s", env, args.path);
+                            return {
+                                contents: serverResult.code,
+                                loader: getLoader(args.path),
+                            };
+                        }
+                        process.env.VERBOSE &&
+                            log("Esbuild no transformation applied for environment=%s, path=%s", env, args.path);
+                    });
+                },
+            });
+            log("Environment configuration complete for env=%s", env);
+        },
+    };
+};

package/dist/vite/ensureAliasArray.d.mts

@@ -0,0 +1,2 @@
+import type { Alias, UserConfig } from "vite";
+export declare const ensureAliasArray: (config: UserConfig) => Alias[];

package/dist/vite/ensureAliasArray.mjs

@@ -0,0 +1,17 @@
+export const ensureAliasArray = (config) => {
+    config.resolve ??= {};
+    if (!config.resolve?.alias) {
+        config.resolve.alias = [];
+    }
+    else if (!Array.isArray(config.resolve.alias)) {
+        const existingAlias = config.resolve.alias;
+        config.resolve.alias = Object.entries(existingAlias).map(([find, replacement]) => ({ find, replacement }));
+    }
+    else {
+        // context(justinvdm, 2025-05-29): The cloning here is necessary:
+        // vite (6.2.6) environments appear to be sharing the same alias
+        // array instance - presumably a result of a deep merge
+        return (config.resolve.alias = [...config.resolve.alias]);
+    }
+    return config.resolve.alias;
+};

package/dist/vite/findSpecifiers.d.mts

@@ -0,0 +1,31 @@
+export declare const IMPORT_PATTERNS: string[];
+export declare const EXPORT_PATTERNS: string[];
+export interface ExportInfo {
+    name: string;
+    isDefault: boolean;
+    alias?: string;
+    originalName?: string;
+    isReExport?: boolean;
+    moduleSpecifier?: string;
+}
+/**
+ * Finds import specifiers and their positions in the code using the provided patterns.
+ * @param code The code to search for import specifiers.
+ * @param lang The language parser to use (TypeScript or Tsx).
+ * @param ignoredImportPatterns Array of regex patterns to ignore.
+ * @param log Optional logger function for debug output.
+ * @returns Array of objects with start, end, and raw import string.
+ */
+export declare function findImportSpecifiers(id: string, code: string, ignoredImportPatterns: RegExp[], log?: (...args: any[]) => void): Array<{
+    s: number;
+    e: number;
+    raw: string;
+}>;
+/**
+ * Finds export information in the code using ast-grep patterns.
+ * @param id The file identifier for language detection.
+ * @param code The code to search for exports.
+ * @param log Optional logger function for debug output.
+ * @returns Array of export information objects.
+ */
+export declare function findExports(id: string, code: string, log?: (...args: any[]) => void): ExportInfo[];