@distilled.cloud/cloudflare-rolldown-plugin 0.3.0 → 0.4.1-beta.1

package/src/plugins/options.ts

@@ -1,8 +1,21 @@
-import type { Plugin } from "rolldown";
-import type { CloudflarePluginOptions } from "../plugin.js";
+import path from "node:path";
+import type * as vite from "vite";
+import { createPlugin } from "../factory.js";
+import type { CloudflarePluginOptions } from "../options.js";
 import { hasNodejsCompat } from "../utils.js";
+import { WORKER_ENTRY_PREFIX } from "./virtual-modules.js";
 
-const DEFAULT_RESOLVE_CONDITION_NAMES = ["workerd", "worker", "module", "browser", "production"];
+function getConditions(options: CloudflarePluginOptions): Array<string> {
+  return hasNodejsCompat(options.compatibilityFlags)
+    ? ["workerd", "worker", "node", "module"]
+    : ["workerd", "worker", "module", "browser"];
+}
+
+function getMainFields(options: CloudflarePluginOptions): Array<string> {
+  return hasNodejsCompat(options.compatibilityFlags)
+    ? ["module", "main", "jsnext:main", "jsnext"]
+    : ["browser", "module", "jsnext:main", "jsnext"];
+}
 
 const DEFAULT_RESOLVE_EXTENSIONS = [
   ".mjs",
@@ -17,35 +30,168 @@ const DEFAULT_RESOLVE_EXTENSIONS = [
   ".ctx",
 ];
 
-export function makeOptionsPlugin(pluginOptions: CloudflarePluginOptions) {
-  return {
-    name: "rolldown-plugin-cloudflare:options",
+const TARGET = "es2024";
+
+export const optionsPlugin = createPlugin("options", (pluginOptions) => ({
+  rolldown: {
     options(options) {
+      options.input = wrapEntryInput(pluginOptions.main ?? options.input ?? {});
+      options.preserveEntrySignatures ??= "strict";
       options.platform ??= "neutral";
       options.resolve ??= {};
-      options.resolve.conditionNames ??= DEFAULT_RESOLVE_CONDITION_NAMES;
+      options.resolve.conditionNames ??= [...getConditions(pluginOptions), "production"];
+      options.resolve.mainFields ??= getMainFields(pluginOptions);
       options.resolve.extensions ??= DEFAULT_RESOLVE_EXTENSIONS;
       options.transform ??= {};
-      options.transform.target ??= "es2024";
+      options.transform.target ??= TARGET;
       options.transform.define ??= {};
-      Object.assign(options.transform.define, {
-        "process.env.NODE_ENV": '"production"',
-        "global.process.env.NODE_ENV": '"production"',
-        "globalThis.process.env.NODE_ENV": '"production"',
-        ...(hasNodejsCompat(pluginOptions.compatibilityFlags)
-          ? {}
-          : {
-              "process.env": "{}",
-              "global.process.env": "{}",
-              "globalThis.process.env": "{}",
-            }),
-        ...(pluginOptions.compatibilityDate && pluginOptions.compatibilityDate >= "2022-03-21"
-          ? {
-              "navigator.userAgent": '"Cloudflare-Workers"',
-            }
-          : {}),
-      });
+      Object.assign(options.transform.define, getDefine(pluginOptions, "production"));
       return options;
     },
-  } satisfies Plugin;
+  },
+  vite: {
+    async config(userConfig) {
+      const vite = await import("vite");
+      const isRolldown = "rolldownVersion" in this.meta;
+      const input =
+        pluginOptions.main ??
+        userConfig.environments?.ssr?.build?.rolldownOptions?.input ??
+        userConfig.environments?.ssr?.build?.rollupOptions?.input;
+      const rollupOptions: vite.Rollup.RollupOptions = {
+        input: wrapEntryInput(input ?? {}),
+        preserveEntrySignatures: "strict",
+      };
+      const define = getDefine(
+        pluginOptions,
+        process.env.NODE_ENV || userConfig.mode || "production",
+      );
+      const conditions = getConditions(pluginOptions);
+      const mainFields = getMainFields(pluginOptions);
+      return {
+        appType: "custom",
+        ssr: {
+          noExternal: true,
+          resolve: {
+            conditions: [...conditions, "development|production"],
+          },
+        },
+        builder: {
+          buildApp: async (app) => {
+            await app.build(app.environments.ssr);
+            await app.build(app.environments.client);
+          },
+        },
+        environments: {
+          client: {
+            build: {
+              outDir: getOutputDirectory(userConfig, "client"),
+            },
+          },
+          ssr: {
+            resolve: {
+              noExternal: true,
+              conditions: [...conditions, "development|production"],
+            },
+            build: {
+              ssr: true,
+              target: TARGET,
+              emitAssets: true,
+              copyPublicDir: false,
+              outDir: getOutputDirectory(userConfig, "ssr"),
+              ...(isRolldown
+                ? {
+                    rolldownOptions: {
+                      ...rollupOptions,
+                      platform: "neutral",
+                      resolve: {
+                        mainFields,
+                        extensions: DEFAULT_RESOLVE_EXTENSIONS,
+                      },
+                    },
+                  }
+                : { rollupOptions }),
+            },
+            optimizeDeps: {
+              noDiscovery: false,
+              ignoreOutdatedRequests: true,
+              entries: pluginOptions.main ? vite.normalizePath(pluginOptions.main) : undefined,
+              ...(isRolldown
+                ? {
+                    rolldownOptions: {
+                      platform: "neutral",
+                      resolve: {
+                        conditionNames: [...conditions, "development|production"],
+                        mainFields,
+                        extensions: DEFAULT_RESOLVE_EXTENSIONS,
+                      },
+                      transform: {
+                        target: TARGET,
+                        define,
+                      },
+                    },
+                  }
+                : {
+                    esbuildOptions: {
+                      platform: "neutral",
+                      conditions: [...conditions, "development|production"],
+                      resolveExtensions: DEFAULT_RESOLVE_EXTENSIONS,
+                      mainFields,
+                      target: TARGET,
+                      define,
+                    },
+                  }),
+            },
+            keepProcessEnv: true,
+          },
+        },
+      };
+    },
+  },
+}));
+
+function wrapEntryInput(input: string | Array<string> | Record<string, string>) {
+  const virtualEntryId = (id: string) => `${WORKER_ENTRY_PREFIX}${id}` as const;
+  if (typeof input === "string") {
+    return { [path.parse(input).name || "index"]: virtualEntryId(input) };
+  }
+  if (Array.isArray(input)) {
+    return Object.fromEntries(input.map((p) => [path.parse(p).name, virtualEntryId(p)]));
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [key, virtualEntryId(value)]),
+  );
+}
+
+function getDefine(options: CloudflarePluginOptions, nodeEnv: string): Record<string, string> {
+  return {
+    "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    "global.process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    "globalThis.process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    ...(hasNodejsCompat(options.compatibilityFlags)
+      ? {}
+      : {
+          "process.env": "{}",
+          "global.process.env": "{}",
+          "globalThis.process.env": "{}",
+        }),
+    ...(options.compatibilityDate && options.compatibilityDate >= "2022-03-21"
+      ? {
+          "navigator.userAgent": '"Cloudflare-Workers"',
+        }
+      : {}),
+    ...(nodeEnv === "production"
+      ? {
+          "import.meta.hot": "false",
+        }
+      : {}),
+  };
+}
+
+function getOutputDirectory(userConfig: vite.UserConfig, environmentName: string) {
+  const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
+
+  return (
+    userConfig.environments?.[environmentName]?.build?.outDir ??
+    path.join(rootOutputDirectory, environmentName)
+  );
 }

package/src/plugins/virtual-modules.ts

@@ -0,0 +1,137 @@
+import type { Plugin } from "rolldown";
+import { createPlugin } from "../factory.js";
+import type { UnenvApi } from "./nodejs-compat.js";
+
+// oxlint-disable-next-line no-control-regex
+const VIRTUAL_MODULE_REGEXP = /^\0distilled:.*$/;
+
+export const WORKER_ENTRY_PREFIX = "\0distilled:worker-entry:" as const;
+const USER_ENTRY_PREFIX = "\0distilled:user-entry:" as const;
+const INJECT_PREFIX = "\0distilled:inject:" as const;
+const EXPORT_TYPES_ID = "\0distilled:export-types" as const;
+
+export const virtualModulesPlugin = createPlugin("virtual-modules", (options) => {
+  let unenvApi: UnenvApi | undefined;
+  const inject = () => {
+    if (!unenvApi) return [];
+    return [
+      ...unenvApi.polyfill.map((module) => `import "${module}";`),
+      ...Object.keys(unenvApi.inject).map(
+        (injectedName) => `import "${INJECT_PREFIX}${injectedName}";`,
+      ),
+    ];
+  };
+  return {
+    vite: {
+      enforce: "pre",
+    },
+    shared: {
+      buildStart({ plugins }) {
+        unenvApi = plugins.find(
+          (plugin): plugin is Plugin<UnenvApi> =>
+            "name" in plugin && plugin.name === "distilled-cloudflare:nodejs-unenv",
+        )?.api;
+      },
+      resolveId: {
+        filter: { id: VIRTUAL_MODULE_REGEXP },
+        handler(id) {
+          if (
+            id.startsWith(WORKER_ENTRY_PREFIX) ||
+            id.startsWith(INJECT_PREFIX) ||
+            id === EXPORT_TYPES_ID
+          ) {
+            return { id };
+          }
+          if (id.startsWith(USER_ENTRY_PREFIX)) {
+            return this.resolve(id.slice(USER_ENTRY_PREFIX.length), undefined, {
+              isEntry: false,
+              kind: "import-statement",
+            });
+          }
+        },
+      },
+      load: {
+        filter: { id: VIRTUAL_MODULE_REGEXP },
+        handler(id) {
+          if (id.startsWith(WORKER_ENTRY_PREFIX)) {
+            const userEntryId = id.replace(WORKER_ENTRY_PREFIX, USER_ENTRY_PREFIX);
+
+            return [
+              ...inject(),
+              ...(options.exports
+                ? [`export { ${options.exports.join(", ")} } from "${userEntryId}";`]
+                : [
+                    `import * as userEntry from "${userEntryId}";`,
+                    `export * from "${userEntryId}";`,
+                    `export default userEntry.default ?? {};`,
+                  ]),
+              "if (import.meta.hot) {",
+              `  const { getExportTypes } = await import("${EXPORT_TYPES_ID}");`,
+              "  import.meta.hot.accept((module) => {",
+              "    const exportTypes = getExportTypes(module);",
+              '    import.meta.hot.send("distilled-cloudflare:worker-export-types", exportTypes);',
+              "  });",
+              "}",
+            ].join("\n");
+          }
+          if (id === EXPORT_TYPES_ID) {
+            return `
+import {
+  WorkerEntrypoint,
+  DurableObject,
+  WorkflowEntrypoint,
+} from "cloudflare:workers";
+
+const baseClasses = new Map([
+  ["WorkerEntrypoint", WorkerEntrypoint],
+  ["DurableObject", DurableObject],
+  ["WorkflowEntrypoint", WorkflowEntrypoint],
+]);
+
+export function getExportTypes(module) {
+  const exportTypes = {};
+
+  for (const [key, value] of Object.entries(module)) {
+    if (key === "default") {
+      continue;
+    }
+
+    let exportType;
+
+    if (typeof value === "function") {
+      for (const [type, baseClass] of baseClasses) {
+        if (baseClass.prototype.isPrototypeOf(value.prototype)) {
+          exportType = type;
+          break;
+        }
+      }
+
+      if (!exportType) {
+        exportType = "DurableObject";
+      }
+    } else if (typeof value === "object" && value !== null) {
+      exportType = "WorkerEntrypoint";
+    }
+
+    exportTypes[key] = exportType;
+  }
+
+  return exportTypes;
+}`;
+          }
+          if (id.startsWith(INJECT_PREFIX)) {
+            const injectedName = id.slice(INJECT_PREFIX.length);
+            const moduleSpecifier = unenvApi?.inject[injectedName];
+            if (!moduleSpecifier) {
+              throw new Error(`Expected module specifier for "${injectedName}" to be defined`);
+            }
+            return [
+              `import ${injectedName} from "${moduleSpecifier}";`,
+              `globalThis.${injectedName} = ${injectedName};`,
+            ].join("\n");
+          }
+        },
+      },
+    },
+  };
+});

package/src/plugins/wasm-init.ts

@@ -1,20 +1,24 @@
-import type { Plugin } from "rolldown";
+import { createPlugin } from "../factory.js";
 import { sanitizePath } from "../utils.js";
 
 const WASM_INIT_QUERY = /\.wasm\?init$/;
 
-export const wasmInitPlugin: Plugin = {
-  name: "rolldown-plugin-cloudflare:wasm-init",
-  load: {
-    filter: { id: WASM_INIT_QUERY },
-    handler(id) {
-      return [
-        `import wasmModule from "${sanitizePath(id)}";`,
-        `export default async (imports) => {`,
-        `  const result = await WebAssembly.instantiate(wasmModule, imports);`,
-        `  return "instance" in result ? result.instance : result;`,
-        `};`,
-      ].join("\n");
+export const wasmInitPlugin = createPlugin("wasm-init", () => ({
+  vite: {
+    enforce: "pre",
+  },
+  shared: {
+    load: {
+      filter: { id: WASM_INIT_QUERY },
+      handler(id) {
+        return [
+          `import wasmModule from "${sanitizePath(id)}";`,
+          `export default async (imports) => {`,
+          `  const result = await WebAssembly.instantiate(wasmModule, imports);`,
+          `  return "instance" in result ? result.instance : result;`,
+          `};`,
+        ].join("\n");
+      },
     },
   },
-};
+}));