rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/vite/miniflareHMRPlugin.mjs

@@ -0,0 +1,209 @@
+import { resolve } from "node:path";
+import colors from "picocolors";
+import { readFile } from "node:fs/promises";
+import debug from "debug";
+import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { hasDirective as sourceHasDirective } from "./hasDirective.mjs";
+import { isJsFile } from "./isJsFile.mjs";
+import { invalidateModule } from "./invalidateModule.mjs";
+import { getShortName } from "../lib/getShortName.mjs";
+const log = debug("rwsdk:vite:hmr-plugin");
+const hasDirective = async (filepath, directive) => {
+    if (!isJsFile(filepath)) {
+        return false;
+    }
+    const content = await readFile(filepath, "utf-8");
+    return sourceHasDirective(content, directive);
+};
+const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
+    // Prevent infinite recursion
+    if (seen.has(module)) {
+        return false;
+    }
+    seen.add(module);
+    // Check direct importers
+    for (const importer of module.importers) {
+        if (importer.file === entryFile)
+            return true;
+        // Recursively check importers
+        if (hasEntryAsAncestor(importer, entryFile, seen))
+            return true;
+    }
+    return false;
+};
+const isInUseClientGraph = ({ file, clientFiles, server, }) => {
+    const id = normalizeModulePath(server.config.root, file);
+    if (clientFiles.has(id)) {
+        return true;
+    }
+    const modules = server.environments.client.moduleGraph.getModulesByFile(file);
+    if (!modules) {
+        return false;
+    }
+    for (const m of modules) {
+        for (const importer of m.importers) {
+            if (importer.file &&
+                isInUseClientGraph({ file: importer.file, clientFiles, server })) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+export const miniflareHMRPlugin = (givenOptions) => [
+    {
+        name: "rwsdk:miniflare-hmr",
+        async hotUpdate(ctx) {
+            const { clientFiles, serverFiles, viteEnvironment: { name: environment }, workerEntryPathname: entry, } = givenOptions;
+            if (process.env.VERBOSE) {
+                log(`Hot update: (env=${this.environment.name}) ${ctx.file}\nModule graph:\n\n${dumpFullModuleGraph(ctx.server, this.environment.name)}`);
+            }
+            if (!isJsFile(ctx.file) && !ctx.file.endsWith(".css")) {
+                return;
+            }
+            if (this.environment.name === "ssr") {
+                log("SSR update, invalidating recursively", ctx.file);
+                const isUseClientUpdate = isInUseClientGraph({
+                    file: ctx.file,
+                    clientFiles,
+                    server: ctx.server,
+                });
+                if (!isUseClientUpdate) {
+                    return [];
+                }
+                invalidateModule(ctx.server, "ssr", ctx.file);
+                invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX +
+                    normalizeModulePath(givenOptions.rootDir, ctx.file));
+                return [];
+            }
+            if (!["client", environment].includes(this.environment.name)) {
+                return [];
+            }
+            const hasClientDirective = await hasDirective(ctx.file, "use client");
+            const hasServerDirective = !hasClientDirective && (await hasDirective(ctx.file, "use server"));
+            let clientDirectiveChanged = false;
+            let serverDirectiveChanged = false;
+            if (!clientFiles.has(ctx.file) && hasClientDirective) {
+                clientFiles.add(ctx.file);
+                clientDirectiveChanged = true;
+            }
+            else if (clientFiles.has(ctx.file) && !hasClientDirective) {
+                clientFiles.delete(ctx.file);
+                clientDirectiveChanged = true;
+            }
+            if (!serverFiles.has(ctx.file) && hasServerDirective) {
+                serverFiles.add(ctx.file);
+                serverDirectiveChanged = true;
+            }
+            else if (serverFiles.has(ctx.file) && !hasServerDirective) {
+                serverFiles.delete(ctx.file);
+                serverDirectiveChanged = true;
+            }
+            if (clientDirectiveChanged) {
+                ["client", "ssr", environment].forEach((environment) => {
+                    invalidateModule(ctx.server, environment, "virtual:use-client-lookup.js");
+                });
+                invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX + "/@id/virtual:use-client-lookup.js");
+            }
+            if (serverDirectiveChanged) {
+                ["client", "ssr", environment].forEach((environment) => {
+                    invalidateModule(ctx.server, environment, "virtual:use-server-lookup.js");
+                });
+                invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX + "/@id/virtual:use-server-lookup.js");
+            }
+            // todo(justinvdm, 12 Dec 2024): Skip client references
+            const modules = Array.from(ctx.server.environments[environment].moduleGraph.getModulesByFile(ctx.file) ?? []);
+            const isWorkerUpdate = Boolean(modules);
+            // The worker needs an update, but this is the client environment
+            // => Notify for HMR update of any css files imported by in worker, that are also in the client module graph
+            // Why: There may have been changes to css classes referenced, which might css modules to change
+            if (this.environment.name === "client") {
+                if (isWorkerUpdate) {
+                    for (const [_, module] of ctx.server.environments[environment]
+                        .moduleGraph.idToModuleMap) {
+                        // todo(justinvdm, 13 Dec 2024): We check+update _all_ css files in worker module graph,
+                        // but it could just be a subset of css files that are actually affected, depending
+                        // on the importers and imports of the changed file. We should be smarter about this.
+                        if (module.file && module.file.endsWith(".css")) {
+                            const clientModules = ctx.server.environments.client.moduleGraph.getModulesByFile(module.file);
+                            for (const clientModule of clientModules ?? []) {
+                                invalidateModule(ctx.server, "client", clientModule);
+                            }
+                        }
+                    }
+                }
+                const isUseClientUpdate = isInUseClientGraph({
+                    file: ctx.file,
+                    clientFiles,
+                    server: ctx.server,
+                });
+                if (!isUseClientUpdate && !ctx.file.endsWith(".css")) {
+                    return [];
+                }
+                return ctx.modules;
+            }
+            // The worker needs an update, and the hot check is for the worker environment
+            // => Notify for custom RSC-based HMR update, then short circuit HMR
+            if (isWorkerUpdate && this.environment.name === environment) {
+                const shortName = getShortName(ctx.file, ctx.server.config.root);
+                this.environment.logger.info(`${colors.green(`worker update`)} ${colors.dim(shortName)}`, {
+                    clear: true,
+                    timestamp: true,
+                });
+                const m = ctx.server.environments.client.moduleGraph
+                    .getModulesByFile(resolve(givenOptions.rootDir, "src", "app", "style.css"))
+                    ?.values()
+                    .next().value;
+                if (m) {
+                    invalidateModule(ctx.server, environment, m);
+                }
+                const virtualSSRModule = ctx.server.environments[environment].moduleGraph.idToModuleMap.get(VIRTUAL_SSR_PREFIX +
+                    normalizeModulePath(givenOptions.rootDir, ctx.file));
+                if (virtualSSRModule) {
+                    invalidateModule(ctx.server, environment, virtualSSRModule);
+                }
+                ctx.server.environments.client.hot.send({
+                    type: "custom",
+                    event: "rsc:update",
+                    data: {
+                        file: ctx.file,
+                    },
+                });
+                return [];
+            }
+        },
+    },
+];
+function dumpFullModuleGraph(server, environment, { includeDisconnected = true } = {}) {
+    const moduleGraph = server.environments[environment].moduleGraph;
+    const seen = new Set();
+    const output = [];
+    function walk(node, depth = 0) {
+        const id = node.id || node.url;
+        if (!id || seen.has(id))
+            return;
+        seen.add(id);
+        const pad = "  ".repeat(depth);
+        const suffix = node.id?.startsWith("virtual:") ? " [virtual]" : "";
+        output.push(`${pad}- ${id}${suffix}`);
+        for (const dep of node.importedModules) {
+            walk(dep, depth + 1);
+        }
+    }
+    // Start with all modules with no importers (roots)
+    const roots = Array.from(moduleGraph.urlToModuleMap.values()).filter((mod) => mod.importers.size === 0);
+    for (const root of roots) {
+        walk(root);
+    }
+    // If requested, show disconnected modules too
+    if (includeDisconnected) {
+        for (const mod of moduleGraph.urlToModuleMap.values()) {
+            const id = mod.id || mod.url;
+            if (!seen.has(id)) {
+                output.push(`- ${id} [disconnected]`);
+            }
+        }
+    }
+    return output.join("\n");
+}

package/dist/vite/moveStaticAssetsPlugin.d.mts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+export declare const moveStaticAssetsPlugin: ({ rootDir, }: {
+    rootDir: string;
+}) => Plugin;

package/dist/vite/moveStaticAssetsPlugin.mjs

@@ -0,0 +1,12 @@
+import { $sh } from "../lib/$.mjs";
+export const moveStaticAssetsPlugin = ({ rootDir, }) => ({
+    name: "rwsdk:move-static-assets",
+    apply: "build",
+    async closeBundle() {
+        if (this.environment.name === "worker") {
+            await $sh({
+                cwd: rootDir,
+            }) `mv dist/worker/assets/*.css dist/client/assets/ || true`;
+        }
+    },
+});

package/dist/vite/normalizeModulePath.d.mts

@@ -0,0 +1 @@
+export declare const normalizeModulePath: (projectRootDir: string, modulePath: string) => string;

package/dist/vite/normalizeModulePath.mjs

@@ -0,0 +1,13 @@
+import path from "node:path";
+export const normalizeModulePath = (projectRootDir, modulePath) => {
+    // /Users/path/to/project/src/foo/bar.ts -> /src/foo/bar.ts
+    if (modulePath.startsWith(projectRootDir)) {
+        return "/" + path.relative(projectRootDir, modulePath);
+    }
+    // /src/foo/bar.ts -> /src/foo/bar.ts
+    if (modulePath.startsWith("/")) {
+        return modulePath;
+    }
+    // src/foo/bar.ts -> /src/foo/bar.ts
+    return "/" + modulePath;
+};

package/dist/vite/prismaPlugin.d.mts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+export declare const prismaPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Promise<Plugin | undefined>;

package/dist/vite/prismaPlugin.mjs

@@ -0,0 +1,43 @@
+import { resolve } from "node:path";
+import { invalidateCacheIfPrismaClientChanged } from "./invalidateCacheIfPrismaClientChanged.mjs";
+import { checkPrismaStatus } from "./checkIsUsingPrisma.mjs";
+import { ensureAliasArray } from "./ensureAliasArray.mjs";
+export const prismaPlugin = async ({ projectRootDir, }) => {
+    if (!checkPrismaStatus({ projectRootDir }).isUsingPrisma) {
+        return;
+    }
+    // context(justinvdm, 10 Mar 2025): We need to use vite optimizeDeps for all deps to work with @cloudflare/vite-plugin.
+    // Thing is, @prisma/client has generated code. So users end up with a stale @prisma/client
+    // when they change their prisma schema and regenerate the client, until clearing out node_modules/.vite
+    // We can't exclude @prisma/client from optimizeDeps since we need it there for @cloudflare/vite-plugin to work.
+    // But we can manually invalidate the cache if the prisma schema changes.
+    await invalidateCacheIfPrismaClientChanged({
+        projectRootDir,
+    });
+    return {
+        name: "rwsdk:prisma",
+        configEnvironment(name, config) {
+            if (name !== "worker") {
+                return;
+            }
+            const wasmPath = resolve(projectRootDir, "node_modules/.prisma/client/wasm.js");
+            config.optimizeDeps ??= {};
+            config.optimizeDeps.esbuildOptions ??= {};
+            config.optimizeDeps.esbuildOptions.plugins ??= [];
+            config.optimizeDeps.esbuildOptions.plugins.push({
+                name: "rwsdk:prisma",
+                setup(build) {
+                    build.onResolve({ filter: /^.prisma\/client\/default/ }, async () => {
+                        return {
+                            path: wasmPath,
+                        };
+                    });
+                },
+            });
+            ensureAliasArray(config).push({
+                find: /^\.prisma\/client\/default/,
+                replacement: wasmPath,
+            });
+        },
+    };
+};

package/dist/vite/reactConditionsResolverPlugin.d.mts

@@ -0,0 +1,16 @@
+import { Plugin } from "vite";
+import enhancedResolve from "enhanced-resolve";
+export declare const ENV_REACT_IMPORTS: {
+    worker: string[];
+    ssr: string[];
+    client: string[];
+};
+export declare const ENV_RESOLVERS: {
+    ssr: enhancedResolve.ResolveFunction;
+    worker: enhancedResolve.ResolveFunction;
+    client: enhancedResolve.ResolveFunction;
+};
+export declare const ENV_IMPORT_MAPPINGS: {
+    [k: string]: Map<string, string>;
+};
+export declare const reactConditionsResolverPlugin: () => Plugin[];

package/dist/vite/reactConditionsResolverPlugin.mjs

@@ -0,0 +1,179 @@
+import debug from "debug";
+import { ROOT_DIR } from "../lib/constants.mjs";
+import enhancedResolve from "enhanced-resolve";
+import { ensureAliasArray } from "./ensureAliasArray.mjs";
+const log = debug("rwsdk:vite:react-conditions-resolver-plugin");
+export const ENV_REACT_IMPORTS = {
+    worker: [
+        "react",
+        "react-dom",
+        "react/jsx-runtime",
+        "react/jsx-dev-runtime",
+        "react-server-dom-webpack/server.edge",
+    ],
+    ssr: [
+        "react",
+        "react-dom",
+        "react/jsx-runtime",
+        "react/jsx-dev-runtime",
+        "react-dom/server.edge",
+        "react-dom/server",
+        "react-server-dom-webpack/client.edge",
+    ],
+    client: [
+        "react",
+        "react-dom",
+        "react-dom/client",
+        "react/jsx-runtime",
+        "react/jsx-dev-runtime",
+        "react-server-dom-webpack/client.browser",
+        "react-server-dom-webpack/client.edge",
+    ],
+};
+export const ENV_RESOLVERS = {
+    ssr: enhancedResolve.create.sync({
+        conditionNames: ["workerd", "worker", "edge", "default"],
+    }),
+    worker: enhancedResolve.create.sync({
+        conditionNames: ["react-server", "workerd", "worker", "edge", "default"],
+    }),
+    client: enhancedResolve.create.sync({
+        conditionNames: ["browser", "default"],
+    }),
+};
+export const ENV_IMPORT_MAPPINGS = Object.fromEntries(Object.keys(ENV_RESOLVERS).map((env) => [
+    env,
+    resolveEnvImportMappings(env),
+]));
+function resolveEnvImportMappings(env) {
+    process.env.VERBOSE &&
+        log("Resolving environment import mappings for env=%s", env);
+    const mappings = new Map();
+    const reactImports = ENV_REACT_IMPORTS[env];
+    for (const importRequest of reactImports) {
+        process.env.VERBOSE &&
+            log("Resolving import request=%s for env=%s", importRequest, env);
+        let resolved = false;
+        try {
+            resolved = ENV_RESOLVERS[env](ROOT_DIR, importRequest);
+            process.env.VERBOSE &&
+                log("Successfully resolved %s to %s for env=%s", importRequest, resolved, env);
+        }
+        catch {
+            process.env.VERBOSE &&
+                log("Failed to resolve %s for env=%s", importRequest, env);
+        }
+        if (resolved) {
+            mappings.set(importRequest, resolved);
+            log("Added mapping for %s -> %s in env=%s", importRequest, resolved, env);
+        }
+    }
+    log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
+    return mappings;
+}
+function createEsbuildResolverPlugin(envName) {
+    const mappings = ENV_IMPORT_MAPPINGS[envName];
+    if (!mappings) {
+        return null;
+    }
+    return {
+        name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, (args) => {
+                process.env.VERBOSE &&
+                    log("ESBuild resolving %s for env=%s, args=%O", args.path, envName, args);
+                const resolved = mappings.get(args.path);
+                if (resolved && args.importer !== "") {
+                    process.env.VERBOSE &&
+                        log("ESBuild resolving %s -> %s for env=%s", args.path, resolved, envName);
+                    if (args.path === "react-server-dom-webpack/client.edge") {
+                        return;
+                    }
+                    return {
+                        path: resolved,
+                    };
+                }
+                else {
+                    process.env.VERBOSE &&
+                        log("ESBuild no resolution found for %s for env=%s", args.path, envName);
+                }
+            });
+        },
+    };
+}
+export const reactConditionsResolverPlugin = () => {
+    log("Initializing react conditions resolver plugin");
+    let isBuild = false;
+    return [
+        {
+            name: "rwsdk:react-conditions-resolver:config",
+            enforce: "post",
+            config(config, { command }) {
+                isBuild = command === "build";
+                log("Configuring plugin for command=%s", command);
+            },
+            configResolved(config) {
+                log("Setting up resolve aliases and optimizeDeps for each environment");
+                // Set up aliases and optimizeDeps for each environment
+                for (const [envName, mappings] of Object.entries(ENV_IMPORT_MAPPINGS)) {
+                    const reactImports = ENV_REACT_IMPORTS[envName];
+                    // Ensure environment config exists
+                    if (!config.environments) {
+                        config.environments = {};
+                    }
+                    if (!config.environments[envName]) {
+                        config.environments[envName] = {};
+                    }
+                    const envConfig = config.environments[envName];
+                    const esbuildPlugin = createEsbuildResolverPlugin(envName);
+                    if (esbuildPlugin && mappings) {
+                        envConfig.optimizeDeps ??= {};
+                        envConfig.optimizeDeps.esbuildOptions ??= {};
+                        envConfig.optimizeDeps.esbuildOptions.define ??= {};
+                        envConfig.optimizeDeps.esbuildOptions.define["process.env.NODE_ENV"] = JSON.stringify(process.env.NODE_ENV);
+                        envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
+                        envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
+                        envConfig.optimizeDeps.include ??= [];
+                        envConfig.optimizeDeps.include.push(...reactImports);
+                        log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
+                    }
+                    const aliases = ensureAliasArray(envConfig);
+                    for (const [find, replacement] of mappings) {
+                        const findRegex = new RegExp(`^${find.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")}$`);
+                        aliases.push({ find: findRegex, replacement });
+                        log("Added alias for env=%s: %s -> %s", envName, find, replacement);
+                    }
+                    log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
+                }
+            },
+        },
+        {
+            name: "rwsdk:react-conditions-resolver:resolveId",
+            enforce: "pre",
+            async resolveId(id, importer) {
+                if (!isBuild) {
+                    return;
+                }
+                const envName = this.environment?.name;
+                if (!envName) {
+                    return;
+                }
+                process.env.VERBOSE &&
+                    log("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
+                const mappings = ENV_IMPORT_MAPPINGS[envName];
+                if (!mappings) {
+                    process.env.VERBOSE &&
+                        log("No mappings found for environment: %s", envName);
+                    return;
+                }
+                const resolved = mappings.get(id);
+                if (resolved) {
+                    log("Resolved %s -> %s for env=%s", id, resolved, envName);
+                    return resolved;
+                }
+                process.env.VERBOSE &&
+                    log("No resolution found for id=%s in env=%s", id, envName);
+            },
+        },
+    ];
+};

package/dist/vite/redwoodPlugin.d.mts

@@ -0,0 +1,12 @@
+import { InlineConfig } from "vite";
+export type RedwoodPluginOptions = {
+    silent?: boolean;
+    rootDir?: string;
+    includeCloudflarePlugin?: boolean;
+    configPath?: string;
+    entry?: {
+        client?: string | string[];
+        worker?: string;
+    };
+};
+export declare const redwoodPlugin: (options?: RedwoodPluginOptions) => Promise<InlineConfig["plugins"]>;

package/dist/vite/redwoodPlugin.mjs

@@ -0,0 +1,105 @@
+import { resolve } from "node:path";
+import { unstable_readConfig } from "wrangler";
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
+import reactPlugin from "@vitejs/plugin-react";
+import tsconfigPaths from "vite-tsconfig-paths";
+import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
+import { directivesPlugin } from "./directivesPlugin.mjs";
+import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
+import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
+import { miniflareHMRPlugin } from "./miniflareHMRPlugin.mjs";
+import { moveStaticAssetsPlugin } from "./moveStaticAssetsPlugin.mjs";
+import { configPlugin } from "./configPlugin.mjs";
+import { $ } from "../lib/$.mjs";
+import { reactConditionsResolverPlugin } from "./reactConditionsResolverPlugin.mjs";
+import { findWranglerConfig } from "../lib/findWranglerConfig.mjs";
+import { pathExists } from "fs-extra";
+import { injectVitePreamble } from "./injectVitePreamblePlugin.mjs";
+import { vitePreamblePlugin } from "./vitePreamblePlugin.mjs";
+import { prismaPlugin } from "./prismaPlugin.mjs";
+import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
+import { hasPkgScript } from "../lib/hasPkgScript.mjs";
+import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
+const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, options) => {
+    if (options.entry?.worker) {
+        return resolve(projectRootDir, options.entry.worker);
+    }
+    const workerConfig = unstable_readConfig({ config: workerConfigPath });
+    return resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx");
+};
+export const redwoodPlugin = async (options = {}) => {
+    const projectRootDir = process.cwd();
+    const workerConfigPath = options.configPath ?? (await findWranglerConfig(projectRootDir));
+    const workerEntryPathname = await determineWorkerEntryPathname(projectRootDir, workerConfigPath, options);
+    const clientEntryPathnames = (Array.isArray(options.entry?.client)
+        ? options.entry.client
+        : [options.entry?.client ?? "src/client.tsx"]).map((entry) => resolve(projectRootDir, entry));
+    const clientFiles = new Set();
+    const serverFiles = new Set();
+    const shouldIncludeCloudflarePlugin = options.includeCloudflarePlugin ??
+        !(await hasOwnCloudflareVitePlugin({ rootProjectDir: projectRootDir }));
+    // context(justinvdm, 31 Mar 2025): We assume that if there is no .wrangler directory,
+    // then this is fresh install, and we run `npm run dev:init` here.
+    if (process.env.RWSDK_WORKER_RUN !== "1" &&
+        process.env.RWSDK_DEPLOY !== "1" &&
+        !(await pathExists(resolve(projectRootDir, ".wrangler"))) &&
+        (await hasPkgScript(projectRootDir, "dev:init"))) {
+        console.log("🚀 Project has no .wrangler directory yet, assuming fresh install: running `npm run dev:init`...");
+        await $({
+            // context(justinvdm, 01 Apr 2025): We want to avoid interactive migration y/n prompt, so we ignore stdin
+            // as a signal to operate in no-tty mode
+            stdio: ["ignore", "inherit", "inherit"],
+        }) `npm run dev:init`;
+    }
+    return [
+        devServerTimingPlugin(),
+        configPlugin({
+            silent: options.silent ?? false,
+            projectRootDir,
+            clientEntryPathnames,
+            workerEntryPathname,
+        }),
+        ssrBridgePlugin({
+            clientFiles,
+            serverFiles,
+            projectRootDir,
+        }),
+        reactConditionsResolverPlugin(),
+        tsconfigPaths({ root: projectRootDir }),
+        shouldIncludeCloudflarePlugin
+            ? cloudflare({
+                viteEnvironment: { name: "worker" },
+                configPath: workerConfigPath,
+            })
+            : [],
+        miniflareHMRPlugin({
+            clientFiles,
+            serverFiles,
+            rootDir: projectRootDir,
+            viteEnvironment: { name: "worker" },
+            workerEntryPathname,
+        }),
+        reactPlugin(),
+        directivesPlugin({
+            projectRootDir,
+            clientFiles,
+            serverFiles,
+        }),
+        vitePreamblePlugin(),
+        injectVitePreamble({ clientEntryPathnames }),
+        useClientLookupPlugin({
+            projectRootDir,
+            clientFiles,
+        }),
+        useServerLookupPlugin({
+            projectRootDir,
+            serverFiles,
+        }),
+        transformJsxScriptTagsPlugin({
+            manifestPath: resolve(projectRootDir, "dist", "client", ".vite", "manifest.json"),
+        }),
+        moveStaticAssetsPlugin({ rootDir: projectRootDir }),
+        prismaPlugin({ projectRootDir }),
+    ];
+};

package/dist/vite/ssrBridgePlugin.d.mts

@@ -0,0 +1,7 @@
+import type { Plugin } from "vite";
+export declare const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
+export declare const ssrBridgePlugin: ({ clientFiles, serverFiles, }: {
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
+    projectRootDir: string;
+}) => Plugin;