rwsdk 0.3.3 → 0.3.5

package/dist/vite/buildApp.mjs

@@ -13,7 +13,7 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     const workerEnv = builder.environments.worker;
     await runDirectivesScan({
         rootConfig: builder.config,
-        environment: workerEnv,
+        environments: builder.environments,
         clientFiles,
         serverFiles,
     });

package/dist/vite/createViteAwareResolver.d.mts

@@ -1,4 +1,5 @@
 import resolve, { ResolveOptions } from "enhanced-resolve";
 import { ResolvedConfig } from "vite";
+import { Environment } from "vite";
 export declare const mapViteResolveToEnhancedResolveOptions: (viteConfig: ResolvedConfig, envName: string) => ResolveOptions;
-export declare const createViteAwareResolver: (viteConfig: ResolvedConfig, envName: string, environment?: any) => resolve.ResolveFunctionAsync;
+export declare const createViteAwareResolver: (viteConfig: ResolvedConfig, environment: Environment) => resolve.ResolveFunctionAsync;

package/dist/vite/createViteAwareResolver.mjs

@@ -238,8 +238,8 @@ export const mapViteResolveToEnhancedResolveOptions = (viteConfig, envName) => {
     };
     return baseOptions;
 };
-export const createViteAwareResolver = (viteConfig, envName, environment) => {
-    const baseOptions = mapViteResolveToEnhancedResolveOptions(viteConfig, envName);
+export const createViteAwareResolver = (viteConfig, environment) => {
+    const baseOptions = mapViteResolveToEnhancedResolveOptions(viteConfig, environment.name);
     // Add Vite plugin resolver if environment is provided
     const plugins = environment
         ? [new VitePluginResolverPlugin(environment)]

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -34,7 +34,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
             // We don't await it here, allowing Vite to continue its startup.
             scanPromise = runDirectivesScan({
                 rootConfig: server.config,
-                environment: server.environments.worker,
+                environments: server.environments,
                 clientFiles,
                 serverFiles,
             }).then(() => {

package/dist/vite/runDirectivesScan.d.mts

@@ -1,7 +1,7 @@
 import { Environment, ResolvedConfig } from "vite";
-export declare const runDirectivesScan: ({ rootConfig, environment, clientFiles, serverFiles, }: {
+export declare const runDirectivesScan: ({ rootConfig, environments, clientFiles, serverFiles, }: {
     rootConfig: ResolvedConfig;
-    environment: Environment;
+    environments: Record<string, Environment>;
     clientFiles: Set<string>;
     serverFiles: Set<string>;
 }) => Promise<void>;

package/dist/vite/runDirectivesScan.mjs

@@ -5,8 +5,7 @@ import debug from "debug";
 import { getViteEsbuild } from "./getViteEsbuild.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { externalModules } from "./constants.mjs";
-import { createViteAwareResolver, mapViteResolveToEnhancedResolveOptions, } from "./createViteAwareResolver.mjs";
-import resolve from "enhanced-resolve";
+import { createViteAwareResolver, } from "./createViteAwareResolver.mjs";
 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
@@ -15,13 +14,13 @@ 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 const runDirectivesScan = async ({ rootConfig, environment, clientFiles, serverFiles, }) => {
+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
     process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE = "true";
     try {
         const esbuild = await getViteEsbuild(rootConfig.root);
-        const input = environment.config.build.rollupOptions?.input;
+        const input = environments.worker.config.build.rollupOptions?.input;
         let entries;
         if (Array.isArray(input)) {
             entries = input;
@@ -36,20 +35,13 @@ export const runDirectivesScan = async ({ rootConfig, environment, clientFiles,
             entries = [];
         }
         if (entries.length === 0) {
-            log("No entries found for directives scan in environment '%s', skipping.", environment.name);
+            log("No entries found for directives scan in worker environment, skipping.");
             return;
         }
         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 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);
+        log("Starting directives scan for worker environment with entries:", absoluteEntries);
+        const workerResolver = createViteAwareResolver(rootConfig, environments.worker);
+        const clientResolver = createViteAwareResolver(rootConfig, environments.client);
         const moduleEnvironments = new Map();
         const fileContentCache = new Map();
         const readFileWithCache = async (path) => {
@@ -153,8 +145,6 @@ export const runDirectivesScan = async ({ rootConfig, environment, clientFiles,
                 });
                 build.onLoad({ filter: /\.(m|c)?[jt]sx?$/ }, async (args) => {
                     log("onLoad called for:", args.path);
-                    const inheritedEnv = args.pluginData?.inheritedEnv || "worker";
-                    log("Inherited environment for", args.path, "is", inheritedEnv);
                     if (!args.path.startsWith("/") ||
                         args.path.includes("virtual:") ||
                         isExternalUrl(args.path)) {
@@ -167,12 +157,28 @@ export const runDirectivesScan = async ({ rootConfig, environment, clientFiles,
                     }
                     try {
                         const contents = await readFileWithCache(args.path);
-                        // The environment is determined in onResolve. Here we just populate the output sets.
-                        if (hasDirective(contents, "use client")) {
+                        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.3",
+  "version": "0.3.5",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {