@cloudflare/vite-plugin 0.0.7 → 0.1.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import assert7 from "node:assert";
+import assert8 from "node:assert";
 import * as fs4 from "node:fs";
 import * as path6 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
@@ -1077,98 +1077,6 @@ import assert from "node:assert";
 import { builtinModules } from "node:module";
 import * as vite2 from "vite";
 
-// src/node-js-compat.ts
-import { createRequire } from "node:module";
-import { getNodeCompat } from "miniflare";
-import * as unenv from "unenv";
-var require2 = createRequire(import.meta.url);
-var preset = unenv.env(unenv.nodeless, unenv.cloudflare);
-var CLOUDFLARE_VIRTUAL_PREFIX = "\0cloudflare-";
-function isNodeCompat({
-  compatibility_date,
-  compatibility_flags
-}) {
-  const nodeCompatMode = getNodeCompat(
-    compatibility_date,
-    compatibility_flags ?? []
-  ).mode;
-  if (nodeCompatMode === "v2") {
-    return true;
-  }
-  if (nodeCompatMode === "legacy") {
-    throw new Error(
-      "Unsupported Node.js compat mode (legacy). Remove the `node_compat` setting and add the `nodejs_compat` flag instead."
-    );
-  }
-  if (nodeCompatMode === "v1") {
-    throw new Error(
-      `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
-    );
-  }
-  return false;
-}
-function injectGlobalCode(id, code, workerConfig) {
-  if (!isNodeCompat(workerConfig)) {
-    return;
-  }
-  const injectedCode = Object.entries(preset.inject).map(([globalName, globalInject]) => {
-    if (typeof globalInject === "string") {
-      const moduleSpecifier2 = globalInject;
-      return `import var_${globalName} from "${moduleSpecifier2}";
-globalThis.${globalName} = var_${globalName};
-`;
-    }
-    const [moduleSpecifier, exportName] = globalInject;
-    return `import var_${globalName} from "${moduleSpecifier}";
-globalThis.${globalName} = var_${globalName}.${exportName};
-`;
-  }).join("\n");
-  const modified = new MagicString(code);
-  modified.prepend(injectedCode);
-  return {
-    code: modified.toString(),
-    map: modified.generateMap({ hires: "boundary", source: id })
-  };
-}
-function getNodeCompatAliases() {
-  const aliases = {};
-  Object.keys(preset.alias).forEach((key) => {
-    if (!preset.external.includes(key)) {
-      aliases[key] = CLOUDFLARE_VIRTUAL_PREFIX + key;
-    }
-  });
-  return aliases;
-}
-function resolveNodeCompatId(environment, workerConfig, id) {
-  const aliased = resolveNodeAliases(id, workerConfig) ?? id;
-  if (aliased.startsWith("unenv/")) {
-    const resolvedDep = require2.resolve(aliased).replace(/\.cjs$/, ".mjs");
-    if (environment.mode === "dev" && environment.depsOptimizer) {
-      const dep = environment.depsOptimizer.registerMissingImport(
-        aliased,
-        resolvedDep
-      );
-      return dep.id;
-    } else {
-      return resolvedDep;
-    }
-  }
-}
-function getNodeCompatExternals() {
-  return preset.external;
-}
-function resolveNodeAliases(source, workerConfig) {
-  if (!source.startsWith(CLOUDFLARE_VIRTUAL_PREFIX) || !isNodeCompat(workerConfig)) {
-    return;
-  }
-  const from = source.slice(CLOUDFLARE_VIRTUAL_PREFIX.length);
-  const alias = preset.alias[from];
-  if (alias && preset.external.includes(alias)) {
-    throw new Error(`Alias to external: ${source} -> ${alias}`);
-  }
-  return alias;
-}
-
 // src/constants.ts
 var ROUTER_WORKER_NAME = "__router-worker__";
 var ASSET_WORKER_NAME = "__asset-worker__";
@@ -1322,12 +1230,13 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
         //       dev pre-bundling crawling (were we not to set this input field we'd have to appropriately set
         //       optimizeDeps.entries in the dev config)
         input: workerConfig.main,
-        external: [...cloudflareBuiltInModules, ...getNodeCompatExternals()]
+        external: [...cloudflareBuiltInModules]
       }
     },
     optimizeDeps: {
       // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
       noDiscovery: false,
+      entries: workerConfig.main,
       exclude: [
         ...cloudflareBuiltInModules,
         // we have to exclude all node modules to work in dev-mode not just the unenv externals...
@@ -1413,33 +1322,33 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
     };
     fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   } else {
-    const workerConfigPaths = Object.fromEntries(
-      Object.keys(resolvedPluginConfig.workers).map((environmentName) => {
-        const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
-        assert2(
-          outputDirectory,
-          `Unexpected error: ${environmentName} environment output directory is undefined`
-        );
-        return [
-          environmentName,
-          getRelativePathToWorkerConfig(
-            deployConfigDirectory,
-            resolvedViteConfig.root,
-            outputDirectory
-          )
-        ];
-      })
-    );
-    const { entryWorkerEnvironmentName } = resolvedPluginConfig;
-    const configPath = workerConfigPaths[entryWorkerEnvironmentName];
+    let entryWorkerConfigPath;
+    const auxiliaryWorkers = [];
+    for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
+      const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
+      assert2(
+        outputDirectory,
+        `Unexpected error: ${environmentName} environment output directory is undefined`
+      );
+      const configPath = getRelativePathToWorkerConfig(
+        deployConfigDirectory,
+        resolvedViteConfig.root,
+        outputDirectory
+      );
+      if (environmentName === resolvedPluginConfig.entryWorkerEnvironmentName) {
+        entryWorkerConfigPath = configPath;
+      } else {
+        auxiliaryWorkers.push({ configPath });
+      }
+    }
     assert2(
-      configPath,
-      `Unexpected error: ${entryWorkerEnvironmentName} environment output directory is undefined`
+      entryWorkerConfigPath,
+      `Unexpected error: entryWorkerConfigPath is undefined`
     );
-    const auxiliaryWorkers = Object.entries(workerConfigPaths).filter(
-      ([environmentName]) => environmentName !== entryWorkerEnvironmentName
-    ).map(([_, configPath2]) => ({ configPath: configPath2 }));
-    const deployConfig = { configPath, auxiliaryWorkers };
+    const deployConfig = {
+      configPath: entryWorkerConfigPath,
+      auxiliaryWorkers
+    };
     fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   }
 }
@@ -1868,13 +1777,94 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
   }
 }
 
+// src/node-js-compat.ts
+import assert5 from "node:assert";
+import { cloudflare } from "@cloudflare/unenv-preset";
+import { getNodeCompat } from "miniflare";
+import { defineEnv } from "unenv";
+var { env } = defineEnv({
+  nodeCompat: true,
+  presets: [cloudflare]
+});
+var CLOUDFLARE_VIRTUAL_PREFIX = "\0__CLOUDFLARE_NODEJS_COMPAT__";
+function isNodeCompat(workerConfig) {
+  if (workerConfig === void 0) {
+    return false;
+  }
+  const nodeCompatMode = getNodeCompat(
+    workerConfig.compatibility_date,
+    workerConfig.compatibility_flags ?? []
+  ).mode;
+  if (nodeCompatMode === "v2") {
+    return true;
+  }
+  if (nodeCompatMode === "legacy") {
+    throw new Error(
+      "Unsupported Node.js compat mode (legacy). Remove the `node_compat` setting and add the `nodejs_compat` flag instead."
+    );
+  }
+  if (nodeCompatMode === "v1") {
+    throw new Error(
+      `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
+    );
+  }
+  return false;
+}
+function injectGlobalCode(id, code) {
+  const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
+    if (typeof globalInject === "string") {
+      const moduleSpecifier2 = globalInject;
+      return `import var_${globalName} from "${moduleSpecifier2}";
+globalThis.${globalName} = var_${globalName};
+`;
+    }
+    const [moduleSpecifier, exportName] = globalInject;
+    return `import var_${globalName} from "${moduleSpecifier}";
+globalThis.${globalName} = var_${globalName}.${exportName};
+`;
+  }).join("\n");
+  const modified = new MagicString(code);
+  modified.prepend(injectedCode);
+  return {
+    code: modified.toString(),
+    map: modified.generateMap({ hires: "boundary", source: id })
+  };
+}
+function getNodeCompatAliases() {
+  const aliases = {};
+  Object.keys(env.alias).forEach((key) => {
+    if (!env.external.includes(key)) {
+      aliases[key] = CLOUDFLARE_VIRTUAL_PREFIX + key;
+    }
+  });
+  return aliases;
+}
+function getNodeCompatExternals() {
+  return env.external;
+}
+function maybeStripNodeJsVirtualPrefix(source) {
+  return source.startsWith(CLOUDFLARE_VIRTUAL_PREFIX) ? source.slice(CLOUDFLARE_VIRTUAL_PREFIX.length) : void 0;
+}
+function dealiasVirtualNodeJSImport(source) {
+  const alias = env.alias[source];
+  assert5(
+    alias,
+    `Expected "${source}" to have a Node.js compat alias, but none was found`
+  );
+  assert5(
+    !env.external.includes(alias),
+    `Unexpected unenv alias to external module: ${source} -> ${alias}`
+  );
+  return alias;
+}
+
 // src/plugin-config.ts
-import assert6 from "node:assert";
+import assert7 from "node:assert";
 import * as path5 from "node:path";
 import * as vite5 from "vite";
 
 // src/workers-configs.ts
-import assert5 from "node:assert";
+import assert6 from "node:assert";
 import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
@@ -2050,17 +2040,17 @@ function getWorkerConfig(configPath, env2, opts) {
   }
   const { raw, config, nonApplicable } = readWorkerConfig(configPath, env2);
   opts?.visitedConfigPaths?.add(configPath);
-  assert5(
+  assert6(
     config.topLevelName,
     missingFieldErrorMessage(`top-level 'name'`, configPath, env2)
   );
-  assert5(config.name, missingFieldErrorMessage(`'name'`, configPath, env2));
-  assert5(
+  assert6(config.name, missingFieldErrorMessage(`'name'`, configPath, env2));
+  assert6(
     config.compatibility_date,
     missingFieldErrorMessage(`'compatibility_date'`, configPath, env2)
   );
   if (opts?.isEntryWorker && !config.main) {
-    assert5(
+    assert6(
       config.assets,
       missingFieldErrorMessage(`'main' or 'assets'`, configPath, env2)
     );
@@ -2077,7 +2067,7 @@ function getWorkerConfig(configPath, env2, opts) {
       nonApplicable
     };
   }
-  assert5(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
+  assert6(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
   return {
     type: "worker",
     raw,
@@ -2115,7 +2105,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     ""
   );
   const configPath = pluginConfig.configPath ? path5.resolve(root, pluginConfig.configPath) : findWranglerConfig(root);
-  assert6(
+  assert7(
     configPath,
     `Config not found. Have you created a wrangler.json(c) or wrangler.toml file?`
   );
@@ -2150,7 +2140,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert6(
+    assert7(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -2267,9 +2257,6 @@ function cloudflare2(pluginConfig = {}) {
         }
         return {
           appType: "custom",
-          resolve: {
-            alias: getNodeCompatAliases()
-          },
           environments: resolvedPluginConfig.type === "workers" ? {
             ...Object.fromEntries(
               Object.entries(resolvedPluginConfig.workers).map(
@@ -2306,7 +2293,7 @@ function cloudflare2(pluginConfig = {}) {
                   resolvedPluginConfig.workers
                 ).map((environmentName) => {
                   const environment = builder.environments[environmentName];
-                  assert7(
+                  assert8(
                     environment,
                     `${environmentName} environment not found`
                   );
@@ -2318,7 +2305,6 @@ function cloudflare2(pluginConfig = {}) {
                   )
                 );
               }
-              writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
             }
           }
         };
@@ -2326,29 +2312,6 @@ function cloudflare2(pluginConfig = {}) {
       configResolved(config) {
         resolvedViteConfig = config;
       },
-      async resolveId(source) {
-        if (resolvedPluginConfig.type === "assets-only") {
-          return;
-        }
-        const workerConfig = resolvedPluginConfig.workers[this.environment.name];
-        if (!workerConfig) {
-          return;
-        }
-        return resolveNodeCompatId(this.environment, workerConfig, source);
-      },
-      async transform(code, id) {
-        if (resolvedPluginConfig.type === "assets-only") {
-          return;
-        }
-        const workerConfig = resolvedPluginConfig.workers[this.environment.name];
-        if (!workerConfig) {
-          return;
-        }
-        const resolvedId = await this.resolve(workerConfig.main);
-        if (id === resolvedId?.id) {
-          return injectGlobalCode(id, code, workerConfig);
-        }
-      },
       generateBundle(_, bundle) {
         let config;
         if (resolvedPluginConfig.type === "workers") {
@@ -2364,7 +2327,7 @@ function cloudflare2(pluginConfig = {}) {
           if (isEntryWorker && workerConfig.assets) {
             const workerOutputDirectory = this.environment.config.build.outDir;
             const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-            assert7(
+            assert8(
               clientOutputDirectory,
               "Unexpected error: client output directory is undefined"
             );
@@ -2413,6 +2376,11 @@ function cloudflare2(pluginConfig = {}) {
           source: JSON.stringify(config)
         });
       },
+      writeBundle() {
+        if (this.environment.name === (resolvedPluginConfig.type === "assets-only" ? "client" : resolvedPluginConfig.entryWorkerEnvironmentName)) {
+          writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
+        }
+      },
       handleHotUpdate(options) {
         if (resolvedPluginConfig.configPaths.has(options.file)) {
           options.server.restart();
@@ -2425,7 +2393,7 @@ function cloudflare2(pluginConfig = {}) {
         }
       },
       async configureServer(viteDevServer) {
-        assert7(
+        assert8(
           viteDevServer.httpServer,
           "Unexpected error: No Vite HTTP server"
         );
@@ -2437,11 +2405,14 @@ function cloudflare2(pluginConfig = {}) {
           resolvedPluginConfig,
           miniflare
         );
-        const middleware = createMiddleware(({ request }) => {
-          return entryWorker.fetch(toMiniflareRequest(request), {
-            redirect: "manual"
-          });
-        });
+        const middleware = createMiddleware(
+          ({ request }) => {
+            return entryWorker.fetch(toMiniflareRequest(request), {
+              redirect: "manual"
+            });
+          },
+          { alwaysCallNext: false }
+        );
         handleWebSocket(
           viteDevServer.httpServer,
           entryWorker.fetch,
@@ -2460,11 +2431,14 @@ function cloudflare2(pluginConfig = {}) {
             pluginConfig.persistState ?? true
           )
         );
-        const middleware = createMiddleware(({ request }) => {
-          return miniflare2.dispatchFetch(toMiniflareRequest(request), {
-            redirect: "manual"
-          });
-        });
+        const middleware = createMiddleware(
+          ({ request }) => {
+            return miniflare2.dispatchFetch(toMiniflareRequest(request), {
+              redirect: "manual"
+            });
+          },
+          { alwaysCallNext: false }
+        );
         handleWebSocket(
           vitePreviewServer.httpServer,
           miniflare2.dispatchFetch,
@@ -2484,19 +2458,14 @@ function cloudflare2(pluginConfig = {}) {
       // Otherwise the `vite:wasm-fallback` plugin prevents the `.wasm` extension being used for module imports.
       enforce: "pre",
       applyToEnvironment(environment) {
-        if (resolvedPluginConfig.type === "assets-only") {
-          return false;
-        }
-        return Object.keys(resolvedPluginConfig.workers).includes(
-          environment.name
-        );
+        return getWorkerConfig2(environment.name) !== void 0;
       },
       async resolveId(source, importer) {
         if (!source.endsWith(".wasm")) {
           return;
         }
         const resolved = await this.resolve(source, importer);
-        assert7(
+        assert8(
           resolved,
           `Unexpected error: could not resolve Wasm module ${source}`
         );
@@ -2512,7 +2481,7 @@ function cloudflare2(pluginConfig = {}) {
         while (match = moduleRE.exec(code)) {
           magicString ??= new MagicString(code);
           const [full, moduleType, modulePath] = match;
-          assert7(
+          assert8(
             modulePath,
             `Unexpected error: module path not found in reference ${full}.`
           );
@@ -2548,8 +2517,74 @@ function cloudflare2(pluginConfig = {}) {
           };
         }
       }
+    },
+    // Plugin that can provide Node.js compatibility support for Vite Environments that are hosted in Cloudflare Workers.
+    {
+      name: "vite-plugin-cloudflare:nodejs-compat",
+      apply(_config, env2) {
+        return !env2.isPreview;
+      },
+      config() {
+        return {
+          resolve: {
+            alias: getNodeCompatAliases()
+          }
+        };
+      },
+      configEnvironment(environmentName) {
+        const workerConfig = getWorkerConfig2(environmentName);
+        if (isNodeCompat(workerConfig)) {
+          return {
+            build: {
+              rollupOptions: {
+                external: getNodeCompatExternals()
+              }
+            }
+          };
+        }
+      },
+      async resolveId(source, importer, options) {
+        const from = maybeStripNodeJsVirtualPrefix(source);
+        if (!from) {
+          return;
+        }
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (!isNodeCompat(workerConfig)) {
+          return this.resolve(from, importer, options);
+        }
+        const unresolvedAlias = dealiasVirtualNodeJSImport(from);
+        const resolvedAlias = await this.resolve(
+          unresolvedAlias,
+          import.meta.url
+        );
+        assert8(
+          resolvedAlias,
+          "Failed to resolve aliased nodejs import: " + unresolvedAlias
+        );
+        if (this.environment.mode === "dev" && this.environment.depsOptimizer) {
+          this.environment.depsOptimizer.registerMissingImport(
+            unresolvedAlias,
+            resolvedAlias.id
+          );
+        }
+        return resolvedAlias;
+      },
+      async transform(code, id) {
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (!isNodeCompat(workerConfig)) {
+          return;
+        }
+        const resolvedId = await this.resolve(workerConfig.main);
+        if (id === resolvedId?.id) {
+          return injectGlobalCode(id, code);
+        }
+      }
     }
   ];
+  function getWorkerConfig2(environmentName) {
+    assert8(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
+    return resolvedPluginConfig.type !== "assets-only" ? resolvedPluginConfig.workers[environmentName] : void 0;
+  }
 }
 function getDotDevDotVarsContent(configPath, cloudflareEnv) {
   const configDir = path6.dirname(configPath);

package/dist/runner-worker/index.js

@@ -25,7 +25,7 @@ function stripInternalEnv(internalEnv) {
   return userEnv;
 }
 
-// ../../node_modules/.pnpm/vite@6.0.7_@types+node@18.19.74_jiti@2.4.2/node_modules/vite/dist/node/module-runner.js
+// ../../node_modules/.pnpm/vite@6.1.0_@types+node@18.19.74_jiti@2.4.2/node_modules/vite/dist/node/module-runner.js
 var VALID_ID_PREFIX = "/@id/";
 var NULL_BYTE_PLACEHOLDER = "__x00__";
 var SOURCEMAPPING_URL = "sourceMa";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -33,10 +33,11 @@
     "dist"
   ],
   "dependencies": {
+    "@cloudflare/unenv-preset": "1.1.1",
     "@hattip/adapter-node": "^0.0.49",
-    "unenv": "npm:unenv-nightly@2.0.0-20241218-183400-5d6aec3",
+    "unenv": "2.0.0-rc.1",
     "ws": "^8.18.0",
-    "miniflare": "3.20250204.0"
+    "miniflare": "3.20250204.1"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250204.0",
@@ -45,13 +46,13 @@
     "magic-string": "^0.30.12",
     "tsup": "8.3.0",
     "typescript": "^5.7.2",
-    "vite": "^6.0.7",
-    "@cloudflare/workers-shared": "0.13.2",
+    "vite": "^6.1.0",
+    "@cloudflare/workers-shared": "0.14.1",
     "@cloudflare/workers-tsconfig": "0.0.0",
-    "wrangler": "3.108.0"
+    "wrangler": "3.109.0"
   },
   "peerDependencies": {
-    "vite": "^6.0.7",
+    "vite": "^6.1.0",
     "wrangler": "^3.101.0"
   },
   "publishConfig": {