@cloudflare/vite-plugin 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/index.ts
 import assert9 from "node:assert";
 import * as fs5 from "node:fs";
+import { builtinModules as builtinModules2 } from "node:module";
 import * as path7 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
 
@@ -1088,13 +1089,9 @@ var INIT_PATH = "/__vite_plugin_cloudflare_init__";
 var MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${MODULE_TYPES.join("|")})__(.*?)__`;
 
 // src/utils.ts
-import { builtinModules } from "node:module";
 import * as path from "node:path";
 import { Request as MiniflareRequest } from "miniflare";
 import "vite";
-var nodeBuiltInModules = new Set(
-  builtinModules.concat(builtinModules.map((m) => `node:${m}`))
-);
 function getOutputDirectory(userConfig, environmentName) {
   const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
   return userConfig.environments?.[environmentName]?.build?.outDir ?? path.join(rootOutputDirectory, environmentName);
@@ -1212,9 +1209,7 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       // We want to use `workerd` package exports if available (e.g. for postgres).
       conditions: [...defaultConditions, "development|production"],
       // The Cloudflare ones are proper builtins in the environment
-      builtins: [...cloudflareBuiltInModules],
-      // The Node.js ones are no proper builtins in the environment since we also polyfill them using unenv
-      external: [...nodeBuiltInModules]
+      builtins: [...cloudflareBuiltInModules]
     },
     dev: {
       createEnvironment(name2, config) {
@@ -1243,10 +1238,6 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
       noDiscovery: false,
       entries: workerConfig.main,
-      exclude: [
-        // we have to exclude all node modules to work in dev-mode not just the unenv externals...
-        ...nodeBuiltInModules
-      ],
       esbuildOptions: {
         platform: "neutral",
         conditions: [...defaultConditions, "development"],
@@ -1592,8 +1583,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
             const moduleRE = new RegExp(MODULE_PATTERN);
             const shouldExternalize = (
               // Worker modules (CompiledWasm, Text, Data)
-              moduleRE.test(moduleId) || // Node.js builtin node modules (they will be resolved to unenv aliases)
-              nodeBuiltInModules.has(moduleId)
+              moduleRE.test(moduleId)
             );
             if (shouldExternalize) {
               const result2 = {
@@ -7313,7 +7303,7 @@ Parser.acorn = {
 };
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
-import { builtinModules as builtinModules2, createRequire } from "node:module";
+import { builtinModules, createRequire } from "node:module";
 import fs3, { realpathSync, statSync as statSync2, promises } from "node:fs";
 
 // ../../node_modules/.pnpm/ufo@1.5.4/node_modules/ufo/dist/index.mjs
@@ -7376,7 +7366,7 @@ import process$1 from "node:process";
 import path4, { dirname as dirname3 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
-var BUILTIN_MODULES = new Set(builtinModules2);
+var BUILTIN_MODULES = new Set(builtinModules);
 function normalizeSlash(path8) {
   return path8.replace(/\\/g, "/");
 }
@@ -8490,7 +8480,7 @@ function parsePackageName(specifier, base) {
   return { packageName, packageSubpath, isScoped };
 }
 function packageResolve(specifier, base, conditions) {
-  if (builtinModules2.includes(specifier)) {
+  if (builtinModules.includes(specifier)) {
     return new URL$1("node:" + specifier);
   }
   const { packageName, packageSubpath, isScoped } = parsePackageName(
@@ -8577,7 +8567,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
     try {
       resolved = new URL$1(specifier);
     } catch (error_) {
-      if (isRemote && !builtinModules2.includes(specifier)) {
+      if (isRemote && !builtinModules.includes(specifier)) {
         const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
         error.cause = error_;
         throw error;
@@ -8722,7 +8712,6 @@ var { env } = defineEnv({
   nodeCompat: true,
   presets: [cloudflare]
 });
-var CLOUDFLARE_VIRTUAL_PREFIX = "\0__CLOUDFLARE_NODEJS_COMPAT__";
 function isNodeCompat(workerConfig) {
   if (workerConfig === void 0) {
     return false;
@@ -8746,16 +8735,39 @@ function isNodeCompat(workerConfig) {
   }
   return false;
 }
+function getNodeCompatEntries() {
+  const entries = new Set(Object.values(env.alias));
+  for (const globalInject of Object.values(env.inject)) {
+    if (typeof globalInject === "string") {
+      entries.add(globalInject);
+    } else {
+      assert6(
+        globalInject[0] !== void 0,
+        "Expected first element of globalInject to be defined"
+      );
+      entries.add(globalInject[0]);
+    }
+  }
+  for (const external of env.external) {
+    entries.delete(external);
+  }
+  return entries;
+}
 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 "${CLOUDFLARE_VIRTUAL_PREFIX}${moduleSpecifier2}";
+      return `import var_${globalName} from "${moduleSpecifier2}";
 globalThis.${globalName} = var_${globalName};
 `;
     }
     const [moduleSpecifier, exportName] = globalInject;
-    return `import var_${globalName} from "${CLOUDFLARE_VIRTUAL_PREFIX}${moduleSpecifier}";
+    assert6(
+      moduleSpecifier !== void 0,
+      "Expected moduleSpecifier to be defined"
+    );
+    assert6(exportName !== void 0, "Expected exportName to be defined");
+    return `import var_${globalName} from "${moduleSpecifier}";
 globalThis.${globalName} = var_${globalName}.${exportName};
 `;
   }).join("\n");
@@ -8766,37 +8778,17 @@ globalThis.${globalName} = var_${globalName}.${exportName};
     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 resolveNodeJSImport(source) {
   const alias = env.alias[source];
   if (alias) {
-    assert6(
-      !env.external.includes(alias),
-      `Unexpected unenv alias to external module: ${source} -> ${alias}`
-    );
-    source = alias;
+    return {
+      unresolved: alias,
+      resolved: resolvePathSync(alias, { url: import.meta.url })
+    };
   }
-  const resolved = resolvePathSync(source, {
-    url: import.meta.url
-  });
-  return {
-    unresolved: source,
-    resolved
-  };
 }
 
 // src/plugin-config.ts
@@ -9465,49 +9457,56 @@ function cloudflare2(pluginConfig = {}) {
       apply(_config, env2) {
         return !env2.isPreview;
       },
-      config() {
-        return {
-          resolve: {
-            alias: getNodeCompatAliases()
-          }
-        };
-      },
-      configEnvironment(environmentName) {
-        const workerConfig = getWorkerConfig2(environmentName);
-        if (isNodeCompat(workerConfig)) {
+      configEnvironment(name2) {
+        if (isNodeCompat(getWorkerConfig2(name2))) {
           return {
-            build: {
-              rollupOptions: {
-                external: getNodeCompatExternals()
-              }
+            resolve: {
+              builtins: getNodeCompatExternals()
+            },
+            optimizeDeps: {
+              // This is a list of dependency entry-points that should be pre-bundled.
+              // In this case we provide a list of all the possible polyfills so that they are pre-bundled,
+              // ready ahead the first request to the dev server.
+              // Without this the dependency optimizer will try to bundle them on-the-fly in the middle of the first request,
+              // which can potentially cause problems if it leads to previous pre-bundling to become stale and needing to be reloaded.
+              include: [...getNodeCompatEntries()],
+              // This is a list of module specifiers that the dependency optimizer should not follow when doing import analysis.
+              // In this case we provide a list of all the Node.js modules, both those built-in to workerd and those that will be polyfilled.
+              // Obviously we don't want/need the optimizer to try to process modules that are built-in;
+              // But also we want to avoid following the ones that are polyfilled since the dependency-optimizer import analyzer does not
+              // resolve these imports using our `resolveId()` hook causing the optimization step to fail.
+              exclude: [
+                ...builtinModules2,
+                ...builtinModules2.map((m) => `node:${m}`)
+              ]
             }
           };
         }
       },
+      applyToEnvironment(environment) {
+        return isNodeCompat(getWorkerConfig2(environment.name));
+      },
+      // We need the resolver from this plugin to run before built-in ones, otherwise Vite's built-in
+      // resolver will try to externalize the Node.js module imports (e.g. `perf_hooks` and `node:tty`)
+      // rather than allowing the resolve hook here to alias then to polyfills.
+      enforce: "pre",
       async resolveId(source, importer, options) {
-        const strippedSource = maybeStripNodeJsVirtualPrefix(source);
-        if (!strippedSource) {
-          return;
-        }
-        const workerConfig = getWorkerConfig2(this.environment.name);
-        if (!isNodeCompat(workerConfig)) {
-          return this.resolve(strippedSource, importer, options);
+        const result = resolveNodeJSImport(source);
+        if (!result) {
+          return this.resolve(source, importer, options);
         }
-        const { unresolved, resolved } = resolveNodeJSImport(strippedSource);
-        if (this.environment.mode === "dev" && this.environment.depsOptimizer) {
-          const optimized = this.environment.depsOptimizer.registerMissingImport(
-            unresolved,
-            resolved
-          ).id;
-          return this.resolve(optimized, importer, options);
+        if (this.environment.mode === "dev") {
+          assert9(
+            this.environment.depsOptimizer,
+            "depsOptimizer is required in dev mode"
+          );
+          return this.resolve(result.unresolved, importer, options);
         }
-        return this.resolve(resolved, importer, options);
+        return this.resolve(result.resolved, importer, options);
       },
       async transform(code, id) {
         const workerConfig = getWorkerConfig2(this.environment.name);
-        if (!isNodeCompat(workerConfig)) {
-          return;
-        }
+        assert9(workerConfig, "Expected a worker config");
         const resolvedId = await this.resolve(workerConfig.main);
         if (id === resolvedId?.id) {
           return injectGlobalCode(id, code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -51,9 +51,9 @@
     "vite": "^6.1.0",
     "vitest": "~3.0.5",
     "@cloudflare/mock-npm-registry": "0.0.0",
-    "@cloudflare/workers-shared": "0.14.3",
     "@cloudflare/workers-tsconfig": "0.0.0",
-    "wrangler": "3.109.2"
+    "wrangler": "3.109.2",
+    "@cloudflare/workers-shared": "0.14.3"
   },
   "peerDependencies": {
     "vite": "^6.1.0",