rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20-test.20250929144616

package/dist/vite/{reactConditionsResolverPlugin.mjs → knownDepsResolverPlugin.mjs}

@@ -1,10 +1,15 @@
 import debug from "debug";
-import { ROOT_DIR } from "../lib/constants.mjs";
 import enhancedResolve from "enhanced-resolve";
+import { ROOT_DIR } from "../lib/constants.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
-const log = debug("rwsdk:vite:react-conditions-resolver-plugin");
-const REACT_PREFIXES = ["react", "react-dom", "react-server-dom-webpack"];
-export const ENV_REACT_IMPORTS = {
+const log = debug("rwsdk:vite:known-deps-resolver-plugin");
+const KNOWN_PREFIXES = [
+    "react",
+    "react-dom",
+    "react-server-dom-webpack",
+    "rwsdk",
+];
+export const ENV_PREDEFINED_IMPORTS = {
     worker: [
         "react",
         "react-dom",
@@ -42,10 +47,10 @@ export const ENV_RESOLVERS = {
         conditionNames: ["browser", "default"],
     }),
 };
-function resolveReactImport(id, envName, projectRootDir, isReactImportKnown = false) {
-    if (!isReactImportKnown) {
-        const isReactImport = REACT_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
-        if (!isReactImport) {
+function resolveKnownImport(id, envName, projectRootDir, isPrefixedImport = false) {
+    if (!isPrefixedImport) {
+        const isKnownImport = KNOWN_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
+        if (!isKnownImport) {
             return undefined;
         }
     }
@@ -70,13 +75,13 @@ function resolveReactImport(id, envName, projectRootDir, isReactImportKnown = fa
     }
     return resolved;
 }
-function resolveEnvImportMappings(env, projectRootDir) {
+function resolvePredefinedEnvImportMappings(env, projectRootDir) {
     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) {
-        const resolved = resolveReactImport(importRequest, env, projectRootDir, true);
+    const predefinedImports = ENV_PREDEFINED_IMPORTS[env];
+    for (const importRequest of predefinedImports) {
+        const resolved = resolveKnownImport(importRequest, env, projectRootDir, true);
         if (resolved) {
             mappings.set(importRequest, resolved);
             process.env.VERBOSE &&
@@ -87,27 +92,27 @@ function resolveEnvImportMappings(env, projectRootDir) {
         log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
     return mappings;
 }
-export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
-    log("Initializing react conditions resolver plugin");
+export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
+    log("Initializing known dependencies resolver plugin");
     let isBuild = false;
     const ENV_IMPORT_MAPPINGS = Object.fromEntries(Object.keys(ENV_RESOLVERS).map((env) => [
         env,
-        resolveEnvImportMappings(env, projectRootDir),
+        resolvePredefinedEnvImportMappings(env, projectRootDir),
     ]));
     // Log a clean summary instead of all the individual mappings
     const totalMappings = Object.values(ENV_IMPORT_MAPPINGS).reduce((sum, mappings) => sum + mappings.size, 0);
-    log("React conditions resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
+    log("Known dependencies resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
     function createEsbuildResolverPlugin(envName, mappings) {
         if (!mappings) {
             return null;
         }
         return {
-            name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
+            name: `rwsdk:known-dependencies-resolver-esbuild-${envName}`,
             setup(build) {
                 build.onResolve({ filter: /.*/ }, (args) => {
                     let resolved = mappings.get(args.path);
                     if (!resolved) {
-                        resolved = resolveReactImport(args.path, envName, projectRootDir);
+                        resolved = resolveKnownImport(args.path, envName, projectRootDir);
                     }
                     if (resolved && args.importer !== "") {
                         if (args.path === "react-server-dom-webpack/client.edge") {
@@ -123,7 +128,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
     }
     return [
         {
-            name: "rwsdk:react-conditions-resolver:config",
+            name: "rwsdk:known-dependencies-resolver:config",
             enforce: "post",
             config(config, { command }) {
                 isBuild = command === "build";
@@ -133,7 +138,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                 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];
+                    const predefinedImports = ENV_PREDEFINED_IMPORTS[envName];
                     // Ensure environment config exists
                     if (!config.environments) {
                         config.environments = {};
@@ -151,7 +156,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                         envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
                         envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
                         envConfig.optimizeDeps.include ??= [];
-                        envConfig.optimizeDeps.include.push(...reactImports);
+                        envConfig.optimizeDeps.include.push(...predefinedImports);
                         log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
                     }
                     const aliases = ensureAliasArray(envConfig);
@@ -161,12 +166,12 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                         process.env.VERBOSE &&
                             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);
+                    log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, predefinedImports.length);
                 }
             },
         },
         {
-            name: "rwsdk:react-conditions-resolver:resolveId",
+            name: "rwsdk:known-dependencies-resolver:resolveId",
             enforce: "pre",
             async resolveId(id, importer) {
                 // Skip during directive scanning to avoid performance issues
@@ -188,7 +193,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                 }
                 let resolved = mappings.get(id);
                 if (!resolved) {
-                    resolved = resolveReactImport(id, envName, projectRootDir);
+                    resolved = resolveKnownImport(id, envName, projectRootDir);
                 }
                 if (resolved) {
                     process.env.VERBOSE &&

package/dist/vite/linkerPlugin.d.mts

@@ -1,4 +1,12 @@
 import type { Plugin } from "vite";
+export declare function linkWorkerBundle({ code, manifestContent, projectRootDir, }: {
+    code: string;
+    manifestContent: string;
+    projectRootDir: string;
+}): {
+    code: string;
+    map: null;
+};
 export declare const linkerPlugin: ({ projectRootDir, }: {
     projectRootDir: string;
 }) => Plugin;

package/dist/vite/linkerPlugin.mjs

@@ -1,9 +1,32 @@
-import path from "node:path";
+import debug from "debug";
 import fsp from "node:fs/promises";
+import path from "node:path";
 import { CLIENT_MANIFEST_RELATIVE_PATH } from "../lib/constants.mjs";
-import debug from "debug";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:linker-plugin");
+export function linkWorkerBundle({ code, manifestContent, projectRootDir, }) {
+    let newCode = code;
+    const manifest = JSON.parse(manifestContent);
+    // 1. Replace the manifest placeholder with the actual manifest content.
+    log("Injecting manifest into worker bundle");
+    newCode = newCode.replace('"__RWSDK_MANIFEST_PLACEHOLDER__"', manifestContent);
+    // 2. Replace asset placeholders with their final hashed paths.
+    log("Replacing asset placeholders in final worker bundle");
+    for (const [key, value] of Object.entries(manifest)) {
+        const normalizedKey = normalizeModulePath(key, projectRootDir, {
+            isViteStyle: false,
+        });
+        newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, `/${value.file}`);
+    }
+    // 3. Deprefix any remaining placeholders that were not in the manifest.
+    // This handles public assets that don't go through the bundler.
+    log("Deprefixing remaining asset placeholders");
+    newCode = newCode.replaceAll("rwsdk_asset:", "");
+    return {
+        code: newCode,
+        map: null,
+    };
+}
 export const linkerPlugin = ({ projectRootDir, }) => {
     return {
         name: "rwsdk:linker",
@@ -13,29 +36,14 @@ export const linkerPlugin = ({ projectRootDir, }) => {
                 return null;
             }
             log("Rendering final worker chunk");
-            let newCode = code;
-            // Read the manifest from the filesystem.
             const manifestContent = await fsp.readFile(path.resolve(projectRootDir, CLIENT_MANIFEST_RELATIVE_PATH), "utf-8");
-            const manifest = JSON.parse(manifestContent);
-            // 1. Replace the manifest placeholder with the actual manifest content.
-            log("Injecting manifest into worker bundle");
-            newCode = newCode.replace('"__RWSDK_MANIFEST_PLACEHOLDER__"', manifestContent);
-            // 2. Replace asset placeholders with their final hashed paths.
-            log("Replacing asset placeholders in final worker bundle");
-            for (const [key, value] of Object.entries(manifest)) {
-                const normalizedKey = normalizeModulePath(key, projectRootDir, {
-                    isViteStyle: false,
-                });
-                newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, `/${value.file}`);
-            }
-            // 3. Deprefix any remaining placeholders that were not in the manifest.
-            // This handles public assets that don't go through the bundler.
-            log("Deprefixing remaining asset placeholders");
-            newCode = newCode.replaceAll("rwsdk_asset:", "");
-            return {
-                code: newCode,
-                map: null,
-            };
+            const result = linkWorkerBundle({
+                code,
+                manifestContent,
+                projectRootDir,
+            });
+            log("Final worker chunk rendered");
+            return result;
         },
     };
 };

package/dist/vite/linkerPlugin.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/linkerPlugin.test.mjs

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { linkWorkerBundle } from "./linkerPlugin.mjs";
+describe("linkWorkerBundle", () => {
+    const projectRootDir = "/test/project";
+    const manifest = {
+        "src/styles.css": { file: "assets/styles.123.css" },
+        "src/logo.svg": { file: "assets/logo.abc.svg" },
+    };
+    const manifestContent = JSON.stringify(manifest);
+    it("should replace the manifest placeholder", () => {
+        const code = `const manifest = "__RWSDK_MANIFEST_PLACEHOLDER__";`;
+        const result = linkWorkerBundle({
+            code,
+            manifestContent,
+            projectRootDir,
+        });
+        expect(result.code).toContain(`const manifest = ${manifestContent};`);
+    });
+    it("should replace asset placeholders with hashed paths from the manifest", () => {
+        const code = `
+      const stylesheet = "rwsdk_asset:/src/styles.css";
+      const logo = "rwsdk_asset:/src/logo.svg";
+    `;
+        const result = linkWorkerBundle({
+            code,
+            manifestContent,
+            projectRootDir,
+        });
+        expect(result.code).toContain(`const stylesheet = "/assets/styles.123.css";`);
+        expect(result.code).toContain(`const logo = "/assets/logo.abc.svg";`);
+    });
+    it("should deprefix remaining asset placeholders not in the manifest", () => {
+        const code = `const publicImg = "rwsdk_asset:/images/photo.jpg";`;
+        const result = linkWorkerBundle({
+            code,
+            manifestContent,
+            projectRootDir,
+        });
+        expect(result.code).toContain(`const publicImg = "/images/photo.jpg";`);
+    });
+});

package/dist/vite/miniflareHMRPlugin.d.mts

@@ -1,4 +1,9 @@
 import { Plugin } from "vite";
+export declare const hasEntryAsAncestor: ({ module, entryFile, seen, }: {
+    module: any;
+    entryFile: string;
+    seen?: Set<any>;
+}) => boolean;
 export declare const miniflareHMRPlugin: (givenOptions: {
     clientFiles: Set<string>;
     serverFiles: Set<string>;

package/dist/vite/miniflareHMRPlugin.mjs

@@ -1,13 +1,13 @@
+import debug from "debug";
+import { readFile } from "node:fs/promises";
 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 { getShortName } from "../lib/getShortName.mjs";
 import { normalizeModulePath } from "../lib/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";
+import { isJsFile } from "./isJsFile.mjs";
+import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
 const log = debug("rwsdk:vite:hmr-plugin");
 let hasErrored = false;
 const hasDirective = async (filepath, directive) => {
@@ -17,7 +17,7 @@ const hasDirective = async (filepath, directive) => {
     const content = await readFile(filepath, "utf-8");
     return sourceHasDirective(content, directive);
 };
-const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
+export const hasEntryAsAncestor = ({ module, entryFile, seen = new Set(), }) => {
     // Prevent infinite recursion
     if (seen.has(module)) {
         return false;
@@ -28,7 +28,7 @@ const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
         if (importer.file === entryFile)
             return true;
         // Recursively check importers
-        if (hasEntryAsAncestor(importer, entryFile, seen))
+        if (hasEntryAsAncestor({ module: importer, entryFile, seen }))
             return true;
     }
     return false;

package/dist/vite/miniflareHMRPlugin.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/miniflareHMRPlugin.test.mjs

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { hasEntryAsAncestor } from "./miniflareHMRPlugin.mjs";
+const createModule = (file) => ({
+    file,
+    importers: new Set(),
+});
+describe("hasEntryAsAncestor", () => {
+    it("should return true if the entry file is a direct importer", () => {
+        const entry = createModule("entry.js");
+        const mod = createModule("mod.js");
+        mod.importers.add(entry);
+        expect(hasEntryAsAncestor({ module: mod, entryFile: "entry.js" })).toBe(true);
+    });
+    it("should return true if the entry file is an indirect importer", () => {
+        const entry = createModule("entry.js");
+        const importer1 = createModule("importer1.js");
+        const mod = createModule("mod.js");
+        importer1.importers.add(entry);
+        mod.importers.add(importer1);
+        expect(hasEntryAsAncestor({ module: mod, entryFile: "entry.js" })).toBe(true);
+    });
+    it("should return false if the entry file is not an importer", () => {
+        const entry = createModule("entry.js");
+        const other = createModule("other.js");
+        const mod = createModule("mod.js");
+        mod.importers.add(other);
+        expect(hasEntryAsAncestor({ module: mod, entryFile: "entry.js" })).toBe(false);
+    });
+    it("should handle circular dependencies", () => {
+        const entry = createModule("entry.js");
+        const modA = createModule("modA.js");
+        const modB = createModule("modB.js");
+        modA.importers.add(entry);
+        modA.importers.add(modB);
+        modB.importers.add(modA);
+        expect(hasEntryAsAncestor({ module: modB, entryFile: "entry.js" })).toBe(true);
+    });
+    it("should return false for a module with no importers", () => {
+        const mod = createModule("mod.js");
+        expect(hasEntryAsAncestor({ module: mod, entryFile: "entry.js" })).toBe(false);
+    });
+});

package/dist/vite/prismaPlugin.mjs

@@ -1,7 +1,7 @@
 import { resolve } from "node:path";
-import { invalidateCacheIfPrismaClientChanged } from "./invalidateCacheIfPrismaClientChanged.mjs";
 import { checkPrismaStatus } from "./checkIsUsingPrisma.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
+import { invalidateCacheIfPrismaClientChanged } from "./invalidateCacheIfPrismaClientChanged.mjs";
 export const prismaPlugin = async ({ projectRootDir, }) => {
     if (!checkPrismaStatus({ projectRootDir }).isUsingPrisma) {
         return;

package/dist/vite/redwoodPlugin.d.mts

@@ -1,12 +1,21 @@
 import { InlineConfig } from "vite";
+import { unstable_readConfig } from "wrangler";
 export type RedwoodPluginOptions = {
     silent?: boolean;
     rootDir?: string;
     includeCloudflarePlugin?: boolean;
     includeReactPlugin?: boolean;
     configPath?: string;
+    forceClientPaths?: string[];
+    forceServerPaths?: string[];
     entry?: {
         worker?: string;
     };
 };
+export declare const determineWorkerEntryPathname: ({ projectRootDir, workerConfigPath, options, readConfig, }: {
+    projectRootDir: string;
+    workerConfigPath: string;
+    options: RedwoodPluginOptions;
+    readConfig?: typeof unstable_readConfig;
+}) => Promise<string>;
 export declare const redwoodPlugin: (options?: RedwoodPluginOptions) => Promise<InlineConfig["plugins"]>;

package/dist/vite/redwoodPlugin.mjs

@@ -1,37 +1,38 @@
+import { cloudflare } from "@cloudflare/vite-plugin";
 import { resolve } from "node:path";
 import { unstable_readConfig } from "wrangler";
-import { cloudflare } from "@cloudflare/vite-plugin";
 import { devServerConstantPlugin } from "./devServerConstant.mjs";
 import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
 import { hasOwnReactVitePlugin } from "./hasOwnReactVitePlugin.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 { pathExists } from "fs-extra";
 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 { configPlugin } from "./configPlugin.mjs";
 import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
-import { manifestPlugin } from "./manifestPlugin.mjs";
-import { linkerPlugin } from "./linkerPlugin.mjs";
 import { directiveModulesDevPlugin } from "./directiveModulesDevPlugin.mjs";
 import { directivesFilteringPlugin } from "./directivesFilteringPlugin.mjs";
-const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, options) => {
+import { directivesPlugin } from "./directivesPlugin.mjs";
+import { injectVitePreamble } from "./injectVitePreamblePlugin.mjs";
+import { knownDepsResolverPlugin } from "./knownDepsResolverPlugin.mjs";
+import { linkerPlugin } from "./linkerPlugin.mjs";
+import { manifestPlugin } from "./manifestPlugin.mjs";
+import { miniflareHMRPlugin } from "./miniflareHMRPlugin.mjs";
+import { moveStaticAssetsPlugin } from "./moveStaticAssetsPlugin.mjs";
+import { prismaPlugin } from "./prismaPlugin.mjs";
+import { resolveForcedPaths } from "./resolveForcedPaths.mjs";
+import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
+import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
+import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
+import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
+import { vitePreamblePlugin } from "./vitePreamblePlugin.mjs";
+export const determineWorkerEntryPathname = async ({ projectRootDir, workerConfigPath, options, readConfig = unstable_readConfig, }) => {
     if (options.entry?.worker) {
         return resolve(projectRootDir, options.entry.worker);
     }
-    const workerConfig = unstable_readConfig({ config: workerConfigPath });
+    const workerConfig = readConfig({ config: workerConfigPath });
     return resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx");
 };
 const clientFiles = new Set();
@@ -39,11 +40,33 @@ const serverFiles = new Set();
 const clientEntryPoints = new Set();
 export const redwoodPlugin = async (options = {}) => {
     const projectRootDir = process.cwd();
+    if (options.forceClientPaths) {
+        const clientPaths = await resolveForcedPaths({
+            patterns: options.forceClientPaths,
+            projectRootDir,
+        });
+        for (const p of clientPaths) {
+            clientFiles.add(p);
+        }
+    }
+    if (options.forceServerPaths) {
+        const serverPaths = await resolveForcedPaths({
+            patterns: options.forceServerPaths,
+            projectRootDir,
+        });
+        for (const p of serverPaths) {
+            serverFiles.add(p);
+        }
+    }
     const workerConfigPath = options.configPath ??
         (process.env.RWSDK_WRANGLER_CONFIG
             ? resolve(projectRootDir, process.env.RWSDK_WRANGLER_CONFIG)
             : await findWranglerConfig(projectRootDir));
-    const workerEntryPathname = await determineWorkerEntryPathname(projectRootDir, workerConfigPath, options);
+    const workerEntryPathname = await determineWorkerEntryPathname({
+        projectRootDir,
+        workerConfigPath,
+        options,
+    });
     const shouldIncludeCloudflarePlugin = options.includeCloudflarePlugin ??
         !(await hasOwnCloudflareVitePlugin({ rootProjectDir: projectRootDir }));
     const shouldIncludeReactPlugin = options.includeReactPlugin ??
@@ -68,6 +91,7 @@ export const redwoodPlugin = async (options = {}) => {
             clientFiles,
             serverFiles,
             projectRootDir,
+            workerEntryPathname,
         }),
         configPlugin({
             silent: options.silent ?? false,
@@ -82,7 +106,7 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
             projectRootDir,
         }),
-        reactConditionsResolverPlugin({ projectRootDir }),
+        knownDepsResolverPlugin({ projectRootDir }),
         tsconfigPaths({ root: projectRootDir }),
         shouldIncludeCloudflarePlugin
             ? cloudflare({

package/dist/vite/redwoodPlugin.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/redwoodPlugin.test.mjs

@@ -0,0 +1,34 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { determineWorkerEntryPathname } from "./redwoodPlugin.mjs";
+describe("determineWorkerEntryPathname", () => {
+    const projectRootDir = "/test/project";
+    it("should use the entry path from options if provided", async () => {
+        const result = await determineWorkerEntryPathname({
+            projectRootDir,
+            workerConfigPath: "/test/project/wrangler.toml",
+            options: { entry: { worker: "src/custom-worker.ts" } },
+        });
+        expect(result).toBe(path.join(projectRootDir, "src/custom-worker.ts"));
+    });
+    it("should use the main path from wrangler config if no entry option is provided", async () => {
+        const readConfig = () => ({ main: "src/wrangler-worker.tsx" });
+        const result = await determineWorkerEntryPathname({
+            projectRootDir,
+            workerConfigPath: "/test/project/wrangler.toml",
+            options: {},
+            readConfig: readConfig,
+        });
+        expect(result).toBe(path.join(projectRootDir, "src/wrangler-worker.tsx"));
+    });
+    it("should use the default path if wrangler config has no main property", async () => {
+        const readConfig = () => ({});
+        const result = await determineWorkerEntryPathname({
+            projectRootDir,
+            workerConfigPath: "/test/project/wrangler.toml",
+            options: {},
+            readConfig: readConfig,
+        });
+        expect(result).toBe(path.join(projectRootDir, "src/worker.tsx"));
+    });
+});

package/dist/vite/resolveForcedPaths.d.mts

@@ -0,0 +1,4 @@
+export declare function resolveForcedPaths({ patterns, projectRootDir, }: {
+    patterns: string[];
+    projectRootDir: string;
+}): Promise<string[]>;

package/dist/vite/resolveForcedPaths.mjs

@@ -0,0 +1,9 @@
+import { glob } from "glob";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+export async function resolveForcedPaths({ patterns, projectRootDir, }) {
+    return (await glob(patterns, {
+        cwd: projectRootDir,
+        absolute: true,
+        realpath: true,
+    })).map((filepath) => normalizeModulePath(filepath, projectRootDir));
+}

package/dist/vite/runDirectivesScan.d.mts

@@ -1,7 +1,28 @@
 import { Environment, ResolvedConfig } from "vite";
-export declare const runDirectivesScan: ({ rootConfig, environments, clientFiles, serverFiles, }: {
+type Resolver = (context: {}, path: string, request: string, resolveContext: {}, callback: (err: Error | null, result?: string | false) => void) => void;
+export declare function resolveModuleWithEnvironment({ path, importer, importerEnv, clientResolver, workerResolver, }: {
+    path: string;
+    importer?: string;
+    importerEnv: "client" | "worker";
+    clientResolver: Resolver;
+    workerResolver: Resolver;
+}): Promise<{
+    id: string;
+} | null>;
+export declare function classifyModule({ contents, inheritedEnv, }: {
+    contents: string;
+    inheritedEnv: "client" | "worker";
+}): {
+    moduleEnv: "client" | "worker";
+    isClient: boolean;
+    isServer: boolean;
+};
+export type EsbuildLoader = "js" | "jsx" | "ts" | "tsx" | "default";
+export declare const runDirectivesScan: ({ rootConfig, environments, clientFiles, serverFiles, entries: initialEntries, }: {
     rootConfig: ResolvedConfig;
     environments: Record<string, Environment>;
     clientFiles: Set<string>;
     serverFiles: Set<string>;
+    entries?: string[];
 }) => Promise<void>;
+export {};