rwsdk 0.3.2 → 0.3.4

package/dist/vite/runDirectivesScan.mjs

@@ -5,7 +5,8 @@ import debug from "debug";
 import { getViteEsbuild } from "./getViteEsbuild.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { externalModules } from "./constants.mjs";
-import { createViteAwareResolver } from "./createViteAwareResolver.mjs";
+import { createViteAwareResolver, mapViteResolveToEnhancedResolveOptions, } from "./createViteAwareResolver.mjs";
+import resolve from "enhanced-resolve";
 const log = debug("rwsdk:vite:run-directives-scan");
 // Copied from Vite's source code.
 // https://github.com/vitejs/vite/blob/main/packages/vite/src/shared/utils.ts
@@ -41,28 +42,23 @@ export const runDirectivesScan = async ({ rootConfig, environment, clientFiles,
         const absoluteEntries = entries.map((entry) => path.resolve(rootConfig.root, entry));
         log("Starting directives scan for environment '%s' with entries:", environment.name, absoluteEntries);
         // Use enhanced-resolve with Vite plugin integration for full compatibility
-        const resolver = createViteAwareResolver(rootConfig, environment.name, environment);
-        const resolveId = async (id, importer) => {
-            return new Promise((resolve) => {
-                resolver({}, importer || rootConfig.root, id, {}, (err, result) => {
-                    if (!err && result) {
-                        resolve({ id: result });
-                    }
-                    else {
-                        if (err) {
-                            // Handle specific enhanced-resolve errors gracefully
-                            const errorMessage = err.message || String(err);
-                            if (errorMessage.includes("Package path . is not exported")) {
-                                log("Package exports error for %s, marking as external", id);
-                            }
-                            else {
-                                log("Resolution failed for %s: %s", id, errorMessage);
-                            }
-                        }
-                        resolve(null);
-                    }
-                });
-            });
+        const workerResolver = createViteAwareResolver(rootConfig, environment.name, environment);
+        // Create a client resolver with browser conditions
+        // We'll use the mapViteResolveToEnhancedResolveOptions function directly
+        // to create a resolver with browser conditions
+        const clientResolveOptions = mapViteResolveToEnhancedResolveOptions(rootConfig, environment.name);
+        // Override the conditions to use browser conditions for client resolution
+        clientResolveOptions.conditionNames = ["browser", "module"];
+        const clientResolver = resolve.create(clientResolveOptions);
+        const moduleEnvironments = new Map();
+        const fileContentCache = new Map();
+        const readFileWithCache = async (path) => {
+            if (fileContentCache.has(path)) {
+                return fileContentCache.get(path);
+            }
+            const contents = await fsp.readFile(path, "utf-8");
+            fileContentCache.set(path, contents);
+            return contents;
         };
         const esbuildScanPlugin = {
             name: "rwsdk:esbuild-scan-plugin",
@@ -92,14 +88,65 @@ export const runDirectivesScan = async ({ rootConfig, environment, clientFiles,
                         return { external: true };
                     }
                     log("onResolve called for:", args.path, "from:", args.importer);
-                    const resolved = await resolveId(args.path, args.importer);
+                    let importerEnv = moduleEnvironments.get(args.importer);
+                    // If we don't know the importer's environment yet, check its content
+                    if (!importerEnv &&
+                        args.importer &&
+                        /\.(m|c)?[jt]sx?$/.test(args.importer)) {
+                        try {
+                            const importerContents = await readFileWithCache(args.importer);
+                            if (hasDirective(importerContents, "use client")) {
+                                importerEnv = "client";
+                                log("Pre-detected importer 'use client' in:", args.importer);
+                            }
+                            else if (hasDirective(importerContents, "use server")) {
+                                importerEnv = "worker";
+                                log("Pre-detected importer 'use server' in:", args.importer);
+                            }
+                            else {
+                                importerEnv = "worker"; // Default for entry points
+                            }
+                            moduleEnvironments.set(args.importer, importerEnv);
+                        }
+                        catch (e) {
+                            importerEnv = "worker"; // Default fallback
+                            log("Could not pre-read importer, using worker environment:", args.importer);
+                        }
+                    }
+                    else if (!importerEnv) {
+                        importerEnv = "worker"; // Default for entry points or non-script files
+                    }
+                    log("Importer:", args.importer, "environment:", importerEnv);
+                    const resolver = importerEnv === "client" ? clientResolver : workerResolver;
+                    const resolved = await new Promise((resolve) => {
+                        resolver({}, args.importer || rootConfig.root, args.path, {}, (err, result) => {
+                            if (!err && result) {
+                                resolve({ id: result });
+                            }
+                            else {
+                                if (err) {
+                                    const errorMessage = err.message || String(err);
+                                    if (errorMessage.includes("Package path . is not exported")) {
+                                        log("Package exports error for %s, marking as external", args.path);
+                                    }
+                                    else {
+                                        log("Resolution failed for %s: %s", args.path, errorMessage);
+                                    }
+                                }
+                                resolve(null);
+                            }
+                        });
+                    });
                     log("Resolution result:", resolved);
                     const resolvedPath = resolved?.id;
                     if (resolvedPath && path.isAbsolute(resolvedPath)) {
                         // Normalize the path for esbuild compatibility
                         const normalizedPath = normalizeModulePath(resolvedPath, rootConfig.root, { absolute: true });
                         log("Normalized path:", normalizedPath);
-                        return { path: normalizedPath };
+                        return {
+                            path: normalizedPath,
+                            pluginData: { inheritedEnv: importerEnv },
+                        };
                     }
                     log("Marking as external:", args.path, "resolved to:", resolvedPath);
                     return { external: true };
@@ -117,12 +164,29 @@ export const runDirectivesScan = async ({ rootConfig, environment, clientFiles,
                         return null;
                     }
                     try {
-                        const contents = await fsp.readFile(args.path, "utf-8");
-                        if (hasDirective(contents, "use client")) {
+                        const contents = await readFileWithCache(args.path);
+                        const inheritedEnv = args.pluginData?.inheritedEnv || "worker";
+                        let currentEnv = inheritedEnv;
+                        const isClient = hasDirective(contents, "use client");
+                        const isServer = hasDirective(contents, "use server");
+                        // A file's own directive takes precedence over the inherited environment.
+                        if (isClient) {
+                            currentEnv = "client";
+                        }
+                        else if (isServer) {
+                            // `else if` handles cases where a file might have both directives.
+                            // "use client" takes precedence.
+                            currentEnv = "worker";
+                        }
+                        // Store the definitive environment for this module, so it can be used when it becomes an importer.
+                        moduleEnvironments.set(args.path, currentEnv);
+                        log("Set environment for", args.path, "to", currentEnv);
+                        // Finally, populate the output sets if the file has a directive.
+                        if (isClient) {
                             log("Discovered 'use client' in:", args.path);
                             clientFiles.add(normalizeModulePath(args.path, rootConfig.root));
                         }
-                        if (hasDirective(contents, "use server")) {
+                        if (isServer) {
                             log("Discovered 'use server' in:", args.path);
                             serverFiles.add(normalizeModulePath(args.path, rootConfig.root));
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {