rwsdk 0.1.0-alpha.9 → 0.1.1

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.mjs

@@ -4,6 +4,7 @@ import debug from "debug";
 import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
 import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { invalidateModule } from "./invalidateModule.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
 const verboseLog = debug("verbose:rwsdk:vite:rsc-directives-plugin");
 const getLoader = (filePath) => {
@@ -26,75 +27,172 @@ const getLoader = (filePath) => {
             return "js";
     }
 };
-export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, }) => ({
-    name: "rwsdk:rsc-directives",
-    async transform(code, id) {
-        verboseLog("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,
-        });
-        if (clientResult) {
-            log("Client component transformation successful for id=%s", id);
-            return {
-                code: clientResult.code,
-                map: clientResult.map,
-            };
+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);
+                invalidateModule(devServer, environment, `virtual:use-${kind}-lookup`);
+            }
         }
-        const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles);
-        if (serverResult) {
-            log("Server function transformation successful for id=%s", id);
-            return {
-                code: serverResult.code,
-                map: serverResult.map,
-            };
-        }
-        verboseLog("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) => {
-                    verboseLog("Esbuild onLoad called for path=%s", args.path);
-                    let code;
-                    try {
-                        code = await fs.readFile(args.path, "utf-8");
-                    }
-                    catch {
-                        verboseLog("Failed to read file: %s", args.path);
-                        return undefined;
-                    }
-                    const clientResult = await transformClientComponents(code, normalizeModulePath(projectRootDir, args.path), {
-                        environmentName: env,
-                        clientFiles,
-                        isEsbuild: true,
+    };
+    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) {
+            verboseLog("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,
+                };
+            }
+            verboseLog("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) => {
+                        verboseLog("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 {
+                            verboseLog("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);
+                            verboseLog("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),
+                            };
+                        }
+                        verboseLog("Esbuild no transformation applied for environment=%s, path=%s", env, args.path);
                     });
-                    if (clientResult) {
-                        log("Esbuild client component transformation successful for path=%s", args.path);
-                        return {
-                            contents: clientResult.code,
-                            loader: getLoader(args.path),
-                        };
-                    }
-                    const serverResult = transformServerFunctions(code, normalizeModulePath(projectRootDir, args.path), env, serverFiles);
-                    if (serverResult) {
-                        log("Esbuild server function transformation successful for path=%s", args.path);
-                        return {
-                            contents: serverResult.code,
-                            loader: getLoader(args.path),
-                        };
-                    }
-                    verboseLog("Esbuild no transformation applied for path=%s", args.path);
-                });
-            },
-        });
-        log("Environment configuration complete for env=%s", env);
-    },
-});
+                },
+            });
+            log("Environment configuration complete for env=%s", env);
+        },
+    };
+};

package/dist/vite/findImportSpecifiers.d.mts

@@ -1,4 +1,12 @@
 export declare const IMPORT_PATTERNS: string[];
+export declare const EXPORT_PATTERNS: string[];
+export interface ExportInfo {
+    name: string;
+    isDefault: boolean;
+    alias?: 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.
@@ -12,3 +20,11 @@ export declare function findImportSpecifiers(id: string, code: string, ignoredIm
     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[];

package/dist/vite/findImportSpecifiers.mjs

@@ -24,6 +24,23 @@ export const IMPORT_PATTERNS = [
     "require('$MODULE')",
     "require(`$MODULE`)",
 ];
+// These patterns are used to match export statements for client/server component transformations
+export const EXPORT_PATTERNS = [
+    // Named exports
+    "export const $NAME = $$$",
+    "export let $NAME = $$$",
+    "export var $NAME = $$$",
+    "export function $NAME($$$) { $$$ }",
+    "export async function $NAME($$$) { $$$ }",
+    // Default exports
+    "export default function $NAME($$$) { $$$ }",
+    "export default function($$$) { $$$ }",
+    "export default $$$",
+    // Export declarations
+    "export { $$$ }",
+    'export { $$$ } from "$MODULE"',
+    "export { $$$ } from '$MODULE'",
+];
 /**
  * Finds import specifiers and their positions in the code using the provided patterns.
  * @param code The code to search for import specifiers.
@@ -74,3 +91,138 @@ export function findImportSpecifiers(id, code, ignoredImportPatterns, log) {
     }
     return results;
 }
+/**
+ * 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 function findExports(id, code, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const results = [];
+    const seen = new Set(); // Track seen exports to avoid duplicates
+    try {
+        const root = sgParse(lang, code);
+        // Use the existing EXPORT_PATTERNS in a specific order to avoid duplicates
+        const orderedPatterns = [
+            // Handle re-exports first (most specific)
+            ...EXPORT_PATTERNS.filter((p) => p.includes('from "$MODULE"') || p.includes("from '$MODULE'")),
+            // Then named exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export const") ||
+                p.startsWith("export let") ||
+                p.startsWith("export var") ||
+                p.startsWith("export function") ||
+                p.startsWith("export async function")),
+            // Then default exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export default")),
+            // Finally export declarations
+            ...EXPORT_PATTERNS.filter((p) => p === "export { $$$ }"),
+        ];
+        for (const pattern of orderedPatterns) {
+            try {
+                const matches = root.root().findAll(pattern);
+                for (const match of matches) {
+                    const nameCapture = match.getMatch("NAME");
+                    const moduleCapture = match.getMatch("MODULE");
+                    const matchText = match.text();
+                    if (pattern.includes('from "$MODULE"') ||
+                        pattern.includes("from '$MODULE'")) {
+                        // Re-export from module
+                        const moduleSpecifier = moduleCapture?.text();
+                        if (!moduleSpecifier)
+                            continue;
+                        if (pattern.includes("export *")) {
+                            // Skip export * for now - too complex
+                            logger("Skipping export * from %s", moduleSpecifier);
+                            continue;
+                        }
+                        // Parse the export list
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:reexport:${moduleSpecifier}`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                    isReExport: true,
+                                    moduleSpecifier,
+                                });
+                                logger("Found re-export: %s from %s", exportName, moduleSpecifier);
+                            }
+                        }
+                    }
+                    else if (matchText.startsWith("export default")) {
+                        // Default export
+                        const name = nameCapture?.text() || "default";
+                        const key = `${name}:true:default`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: true,
+                        });
+                        logger("Found default export: %s", name);
+                    }
+                    else if (matchText.includes("export {")) {
+                        // Local export declaration
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:local`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                });
+                                logger("Found local export: %s", exportName);
+                            }
+                        }
+                    }
+                    else if (nameCapture) {
+                        // Named export (function, const, etc.)
+                        const name = nameCapture.text();
+                        const key = `${name}:false:named`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: false,
+                        });
+                        logger("Found named export: %s", name);
+                    }
+                }
+            }
+            catch (err) {
+                logger("Error processing export pattern %s: %O", pattern, err);
+            }
+        }
+    }
+    catch (err) {
+        logger("Error parsing code for exports: %O", err);
+    }
+    return results;
+}

package/dist/vite/findImportSpecifiers.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/findImportSpecifiers.test.mjs

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+import { findExports } from "./findImportSpecifiers.mjs";
+describe("findExports", () => {
+    it("finds named exports", () => {
+        const code = `
+export const Component = () => {};
+export function helper() {}
+export let data = {};
+`;
+        const exports = findExports("/test.tsx", code);
+        // Just check that we found the exports, order doesn't matter for our use case
+        const names = exports.map((e) => e.name).sort();
+        expect(names).toEqual(["Component", "data", "helper"]);
+        // Check that none are default
+        expect(exports.every((e) => !e.isDefault)).toBe(true);
+    });
+    it("finds default exports", () => {
+        const code = `
+export default function Component() {}
+`;
+        const exports = findExports("/test.tsx", code);
+        // Should find at least one default export
+        const defaultExports = exports.filter((e) => e.isDefault);
+        expect(defaultExports.length).toBeGreaterThan(0);
+        expect(defaultExports.some((e) => e.name === "Component")).toBe(true);
+    });
+    it("finds export declarations", () => {
+        const code = `
+const First = () => {};
+const Second = () => {};
+export { First, Second };
+`;
+        const exports = findExports("/test.tsx", code);
+        const names = exports.map((e) => e.name).sort();
+        expect(names).toEqual(["First", "Second"]);
+    });
+    it("finds export declarations with aliases", () => {
+        const code = `
+const Component = () => {};
+export { Component as MyComponent };
+`;
+        const exports = findExports("/test.tsx", code);
+        expect(exports.some((e) => e.name === "MyComponent")).toBe(true);
+    });
+    it("finds re-exports", () => {
+        const code = `
+export { sum } from './math';
+export { default as multiply } from './multiply';
+`;
+        const exports = findExports("/test.tsx", code);
+        // Should find re-exports
+        const reExports = exports.filter((e) => e.isReExport);
+        expect(reExports.length).toBeGreaterThan(0);
+        const names = reExports.map((e) => e.name).sort();
+        expect(names).toContain("sum");
+        expect(names).toContain("multiply");
+    });
+    it("handles mixed export styles", () => {
+        const code = `
+export const First = () => {};
+const Second = () => {};
+export default function Main() {}
+export { Second };
+`;
+        const exports = findExports("/test.tsx", code);
+        const names = exports.map((e) => e.name);
+        expect(names).toContain("First");
+        expect(names).toContain("Second");
+        // Should have at least one default export
+        const defaultExports = exports.filter((e) => e.isDefault);
+        expect(defaultExports.length).toBeGreaterThan(0);
+    });
+});

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[];