rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/vite/runDirectivesScan.mjs

@@ -14,6 +14,40 @@ const isObject = (value) => Object.prototype.toString.call(value) === "[object O
 // https://github.com/vitejs/vite/blob/main/packages/vite/src/node/utils.ts
 const externalRE = /^(https?:)?\/\//;
 const isExternalUrl = (url) => externalRE.test(url);
+export async function resolveModuleWithEnvironment({ path, importer, importerEnv, clientResolver, workerResolver, }) {
+    const resolver = importerEnv === "client" ? clientResolver : workerResolver;
+    return new Promise((resolvePromise) => {
+        resolver({}, importer || "", path, {}, (err, result) => {
+            if (!err && result) {
+                resolvePromise({ 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", path);
+                    }
+                    else {
+                        log("Resolution failed for %s: %s", path, errorMessage);
+                    }
+                }
+                resolvePromise(null);
+            }
+        });
+    });
+}
+export function classifyModule({ contents, inheritedEnv, }) {
+    let moduleEnv = inheritedEnv;
+    const isClient = hasDirective(contents, "use client");
+    const isServer = hasDirective(contents, "use server");
+    if (isClient) {
+        moduleEnv = "client";
+    }
+    else if (isServer) {
+        moduleEnv = "worker";
+    }
+    return { moduleEnv, isClient, isServer };
+}
 export const runDirectivesScan = async ({ rootConfig, environments, clientFiles, serverFiles, }) => {
     console.log("\n🔍 Scanning for 'use client' and 'use server' directives...");
     // Set environment variable to indicate scanning is in progress
@@ -87,17 +121,12 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                         /\.(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
-                            }
+                            const classification = classifyModule({
+                                contents: importerContents,
+                                inheritedEnv: "worker", // Default for entry points
+                            });
+                            importerEnv = classification.moduleEnv;
+                            log("Pre-detected importer environment in:", args.importer, "as", importerEnv);
                             moduleEnvironments.set(args.importer, importerEnv);
                         }
                         catch (e) {
@@ -109,25 +138,12 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                         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);
-                            }
-                        });
+                    const resolved = await resolveModuleWithEnvironment({
+                        path: args.path,
+                        importer: args.importer,
+                        importerEnv,
+                        clientResolver,
+                        workerResolver,
                     });
                     log("Resolution result:", resolved);
                     const resolvedPath = resolved?.id;
@@ -158,21 +174,13 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
                     try {
                         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";
-                        }
+                        const { moduleEnv, isClient, isServer } = classifyModule({
+                            contents,
+                            inheritedEnv,
+                        });
                         // 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);
+                        moduleEnvironments.set(args.path, moduleEnv);
+                        log("Set environment for", args.path, "to", moduleEnv);
                         // Finally, populate the output sets if the file has a directive.
                         if (isClient) {
                             log("Discovered 'use client' in:", args.path);

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

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

package/dist/vite/runDirectivesScan.test.mjs

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi } from "vitest";
+import { resolveModuleWithEnvironment, classifyModule, } from "./runDirectivesScan.mjs";
+describe("runDirectivesScan helpers", () => {
+    describe("resolveModuleWithEnvironment", () => {
+        it("should use the client resolver when importerEnv is 'client'", async () => {
+            const clientResolver = vi.fn((_a, _b, _c, _d, cb) => cb(null, "/resolved/client"));
+            const workerResolver = vi.fn();
+            const result = await resolveModuleWithEnvironment({
+                path: "test-path",
+                importerEnv: "client",
+                clientResolver,
+                workerResolver,
+            });
+            expect(clientResolver).toHaveBeenCalled();
+            expect(workerResolver).not.toHaveBeenCalled();
+            expect(result).toEqual({ id: "/resolved/client" });
+        });
+        it("should use the worker resolver when importerEnv is 'worker'", async () => {
+            const clientResolver = vi.fn();
+            const workerResolver = vi.fn((_a, _b, _c, _d, cb) => cb(null, "/resolved/worker"));
+            const result = await resolveModuleWithEnvironment({
+                path: "test-path",
+                importerEnv: "worker",
+                clientResolver,
+                workerResolver,
+            });
+            expect(workerResolver).toHaveBeenCalled();
+            expect(clientResolver).not.toHaveBeenCalled();
+            expect(result).toEqual({ id: "/resolved/worker" });
+        });
+        it("should return null on resolution error", async () => {
+            const clientResolver = vi.fn((_a, _b, _c, _d, cb) => cb(new Error("Resolution failed")));
+            const workerResolver = vi.fn();
+            const result = await resolveModuleWithEnvironment({
+                path: "test-path",
+                importerEnv: "client",
+                clientResolver,
+                workerResolver,
+            });
+            expect(result).toBeNull();
+        });
+    });
+    describe("classifyModule", () => {
+        it("should return 'client' if 'use client' directive is present", () => {
+            const contents = `'use client';\nconsole.log('hello');`;
+            const result = classifyModule({ contents, inheritedEnv: "worker" });
+            expect(result.moduleEnv).toBe("client");
+            expect(result.isClient).toBe(true);
+            expect(result.isServer).toBe(false);
+        });
+        it("should return 'worker' if 'use server' directive is present", () => {
+            const contents = `"use server";\nexport default () => {};`;
+            const result = classifyModule({ contents, inheritedEnv: "client" });
+            expect(result.moduleEnv).toBe("worker");
+            expect(result.isClient).toBe(false);
+            expect(result.isServer).toBe(true);
+        });
+        it("should prioritize 'use client' over 'use server'", () => {
+            const contents = `'use client';\n'use server';\nconsole.log('hello');`;
+            const result = classifyModule({ contents, inheritedEnv: "worker" });
+            expect(result.moduleEnv).toBe("client");
+            expect(result.isClient).toBe(true);
+            expect(result.isServer).toBe(false);
+        });
+        it("should return the inherited environment if no directive is present", () => {
+            const contents = `console.log('no directive');`;
+            const result = classifyModule({ contents, inheritedEnv: "worker" });
+            expect(result.moduleEnv).toBe("worker");
+            expect(result.isClient).toBe(false);
+            expect(result.isServer).toBe(false);
+        });
+    });
+});

package/package.json

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