rwsdk 0.1.0-alpha.9 → 0.1.1

package/dist/vite/findSpecifiers.mjs

@@ -0,0 +1,230 @@
+import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
+import path from "path";
+// These patterns are used to match import statements in code for SSR transformations.
+export const IMPORT_PATTERNS = [
+    'import { $$$ } from "$MODULE"',
+    "import { $$$ } from '$MODULE'",
+    'import $DEFAULT from "$MODULE"',
+    "import $DEFAULT from '$MODULE'",
+    'import * as $NS from "$MODULE"',
+    "import * as $NS from '$MODULE'",
+    'import "$MODULE"',
+    "import '$MODULE'",
+    // Static Re-exports
+    'export { $$$ } from "$MODULE"',
+    "export { $$$ } from '$MODULE'",
+    'export * from "$MODULE"',
+    "export * from '$MODULE'",
+    // Dynamic Imports
+    'import("$MODULE")',
+    "import('$MODULE')",
+    "import(`$MODULE`)",
+    // CommonJS require
+    'require("$MODULE")',
+    "require('$MODULE')",
+    "require(`$MODULE`)",
+];
+// These patterns are used to match export statements for client/server component transformations
+export const EXPORT_PATTERNS = [
+    // Named exports
+    "export const $NAME = $$$",
+    "export let $NAME = $$$",
+    "export var $NAME = $$$",
+    "export function $NAME($$$) { $$$ }",
+    "export async function $NAME($$$) { $$$ }",
+    // Default exports
+    "export default function $NAME($$$) { $$$ }",
+    "export default function($$$) { $$$ }",
+    "export default $$$",
+    // Export declarations
+    "export { $$$ }",
+    'export { $$$ } from "$MODULE"',
+    "export { $$$ } from '$MODULE'",
+];
+/**
+ * Finds import specifiers and their positions in the code using the provided patterns.
+ * @param code The code to search for import specifiers.
+ * @param lang The language parser to use (TypeScript or Tsx).
+ * @param ignoredImportPatterns Array of regex patterns to ignore.
+ * @param log Optional logger function for debug output.
+ * @returns Array of objects with start, end, and raw import string.
+ */
+export function findImportSpecifiers(id, code, ignoredImportPatterns, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const results = [];
+    try {
+        // sgParse and lang must be provided by the consumer
+        const root = sgParse(lang, code);
+        for (const pattern of IMPORT_PATTERNS) {
+            try {
+                const matches = root.root().findAll(pattern);
+                for (const match of matches) {
+                    const moduleCapture = match.getMatch("MODULE");
+                    if (moduleCapture) {
+                        const importPath = moduleCapture.text();
+                        if (importPath.startsWith("virtual:")) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it starts with 'virtual:': importPath=%s", importPath);
+                        }
+                        else if (importPath.includes("__rwsdknossr")) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it includes '__rwsdknossr': importPath=%s", importPath);
+                        }
+                        else if (ignoredImportPatterns.some((pattern) => pattern.test(importPath))) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it matches IGNORED_IMPORT_PATTERNS: importPath=%s", importPath);
+                        }
+                        else {
+                            const { start, end } = moduleCapture.range();
+                            results.push({ s: start.index, e: end.index, raw: importPath });
+                            logger(":findImportSpecifiersWithPositions: Including import specifier: importPath=%s, range=[%d, %d]", importPath, start.index, end.index);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger(":findImportSpecifiersWithPositions: Error processing pattern: %O", err);
+            }
+        }
+    }
+    catch (err) {
+        logger(":findImportSpecifiersWithPositions: Error parsing content: %O", err);
+    }
+    return results;
+}
+/**
+ * Finds export information in the code using ast-grep patterns.
+ * @param id The file identifier for language detection.
+ * @param code The code to search for exports.
+ * @param log Optional logger function for debug output.
+ * @returns Array of export information objects.
+ */
+export function findExports(id, code, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const results = [];
+    const seen = new Set(); // Track seen exports to avoid duplicates
+    try {
+        const root = sgParse(lang, code);
+        // Use the existing EXPORT_PATTERNS in a specific order to avoid duplicates
+        const orderedPatterns = [
+            // Handle re-exports first (most specific)
+            ...EXPORT_PATTERNS.filter((p) => p.includes('from "$MODULE"') || p.includes("from '$MODULE'")),
+            // Then named exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export const") ||
+                p.startsWith("export let") ||
+                p.startsWith("export var") ||
+                p.startsWith("export function") ||
+                p.startsWith("export async function")),
+            // Then default exports
+            ...EXPORT_PATTERNS.filter((p) => p.startsWith("export default")),
+            // Finally export declarations
+            ...EXPORT_PATTERNS.filter((p) => p === "export { $$$ }"),
+        ];
+        for (const pattern of orderedPatterns) {
+            try {
+                const matches = root.root().findAll(pattern);
+                for (const match of matches) {
+                    const nameCapture = match.getMatch("NAME");
+                    const moduleCapture = match.getMatch("MODULE");
+                    const matchText = match.text();
+                    if (pattern.includes('from "$MODULE"') ||
+                        pattern.includes("from '$MODULE'")) {
+                        // Re-export from module
+                        const moduleSpecifier = moduleCapture?.text();
+                        if (!moduleSpecifier)
+                            continue;
+                        if (pattern.includes("export *")) {
+                            // Skip export * for now - too complex
+                            logger("Skipping export * from %s", moduleSpecifier);
+                            continue;
+                        }
+                        // Parse the export list
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:reexport:${moduleSpecifier}`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                    originalName: originalName,
+                                    isReExport: true,
+                                    moduleSpecifier,
+                                });
+                                logger("Found re-export: %s from %s", exportName, moduleSpecifier);
+                            }
+                        }
+                    }
+                    else if (matchText.startsWith("export default")) {
+                        // Default export
+                        const name = nameCapture?.text() || "default";
+                        const key = `${name}:true:default`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: true,
+                        });
+                        logger("Found default export: %s", name);
+                    }
+                    else if (matchText.includes("export {")) {
+                        // Local export declaration
+                        const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
+                        if (exportListMatch) {
+                            const exportList = exportListMatch[1];
+                            const exports = exportList.split(",").map((e) => e.trim());
+                            for (const exp of exports) {
+                                const [originalName, alias] = exp.includes(" as ")
+                                    ? exp.split(" as ").map((s) => s.trim())
+                                    : [exp.trim(), undefined];
+                                const exportName = alias || originalName;
+                                const key = `${exportName}:${originalName === "default"}:local`;
+                                if (seen.has(key))
+                                    continue;
+                                seen.add(key);
+                                results.push({
+                                    name: exportName,
+                                    isDefault: originalName === "default",
+                                    alias: alias !== originalName ? alias : undefined,
+                                    originalName: originalName,
+                                });
+                                logger("Found local export: %s", exportName);
+                            }
+                        }
+                    }
+                    else if (nameCapture) {
+                        // Named export (function, const, etc.)
+                        const name = nameCapture.text();
+                        const key = `${name}:false:named`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        results.push({
+                            name,
+                            isDefault: false,
+                        });
+                        logger("Found named export: %s", name);
+                    }
+                }
+            }
+            catch (err) {
+                logger("Error processing export pattern %s: %O", pattern, err);
+            }
+        }
+    }
+    catch (err) {
+        logger("Error parsing code for exports: %O", err);
+    }
+    return results;
+}

package/dist/vite/hasDirective.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Efficiently checks if a React directive (e.g., "use server", "use client")
+ * is present in the code. Optimized for performance with a two-step approach:
+ * 1. Quick string search to see if directive exists anywhere
+ * 2. Line-by-line check only if the directive might be present
+ */
+export declare function hasDirective(code: string, directive: string): boolean;

package/dist/vite/hasDirective.mjs

@@ -0,0 +1,54 @@
+/**
+ * Efficiently checks if a React directive (e.g., "use server", "use client")
+ * is present in the code. Optimized for performance with a two-step approach:
+ * 1. Quick string search to see if directive exists anywhere
+ * 2. Line-by-line check only if the directive might be present
+ */
+export function hasDirective(code, directive) {
+    // Quick performance check: if directive doesn't exist anywhere, skip line checking
+    const singleQuoteDirective = `'${directive}'`;
+    const doubleQuoteDirective = `"${directive}"`;
+    if (!code.includes(singleQuoteDirective) &&
+        !code.includes(doubleQuoteDirective)) {
+        return false;
+    }
+    // Split into lines and check each one
+    const lines = code.split("\n");
+    let inMultiLineComment = false;
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // Skip empty lines
+        if (trimmedLine.length === 0) {
+            continue;
+        }
+        // Handle multi-line comments
+        if (trimmedLine.startsWith("/*")) {
+            inMultiLineComment = true;
+            // Check if the comment ends on the same line
+            if (trimmedLine.includes("*/")) {
+                inMultiLineComment = false;
+            }
+            continue;
+        }
+        if (inMultiLineComment) {
+            // Check if this line ends the multi-line comment
+            if (trimmedLine.includes("*/")) {
+                inMultiLineComment = false;
+            }
+            continue;
+        }
+        // Skip single-line comments
+        if (trimmedLine.startsWith("//")) {
+            continue;
+        }
+        // Check if this line starts with the directive
+        if (trimmedLine.startsWith(doubleQuoteDirective) ||
+            trimmedLine.startsWith(singleQuoteDirective)) {
+            return true;
+        }
+        // If we hit a non-empty, non-comment line that's not a directive, we can stop
+        // (directives must be at the top of the file/scope, after comments)
+        break;
+    }
+    return false;
+}

package/dist/vite/hasOwnCloudflareVitePlugin.d.mts

@@ -0,0 +1,3 @@
+export declare function hasOwnCloudflareVitePlugin({ rootProjectDir, }: {
+    rootProjectDir: string;
+}): Promise<boolean>;

package/dist/vite/hasOwnCloudflareVitePlugin.mjs

@@ -0,0 +1,14 @@
+import { readFile } from "fs/promises";
+import path from "path";
+export async function hasOwnCloudflareVitePlugin({ rootProjectDir, }) {
+    const packageJsonPath = path.join(rootProjectDir, "package.json");
+    try {
+        const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        return !!(packageJson.dependencies?.["@cloudflare/vite-plugin"] ||
+            packageJson.devDependencies?.["@cloudflare/vite-plugin"]);
+    }
+    catch (error) {
+        console.error("Error reading package.json:", error);
+        return false;
+    }
+}

package/dist/vite/injectVitePreamblePlugin.d.mts

@@ -1,5 +1,5 @@
 import { type Plugin } from "vite";
-export declare const injectVitePreamble: ({ clientEntryPathname, mode, }: {
-    clientEntryPathname: string;
+export declare const injectVitePreamble: ({ clientEntryPathnames, mode, }: {
+    clientEntryPathnames: string[];
     mode: "development" | "production";
 }) => Plugin;

package/dist/vite/injectVitePreamblePlugin.mjs

@@ -1,9 +1,12 @@
 import MagicString from "magic-string";
-export const injectVitePreamble = ({ clientEntryPathname, mode, }) => ({
+export const injectVitePreamble = ({ clientEntryPathnames, mode, }) => ({
     name: "rwsdk:inject-vite-preamble",
     apply: "serve",
     transform(code, id) {
-        if (id !== clientEntryPathname) {
+        if (this.environment.name !== "client") {
+            return;
+        }
+        if (!clientEntryPathnames.includes(id)) {
             return;
         }
         // Only inject preamble in development mode

package/dist/vite/invalidateModule.d.mts

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from "vite";
+export declare const invalidateModule: (devServer: ViteDevServer, environment: string, id: string) => void;

package/dist/vite/invalidateModule.mjs

@@ -0,0 +1,14 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:invalidate-module");
+const verboseLog = debug("verbose:rwsdk:vite:invalidate-module");
+export const invalidateModule = (devServer, environment, id) => {
+    const [rawId, _query] = id.split("?");
+    log("Invalidating module: id=%s, environment=%s", id, environment);
+    const moduleNode = devServer?.environments[environment]?.moduleGraph.idToModuleMap.get(rawId);
+    if (moduleNode) {
+        devServer?.environments[environment]?.moduleGraph.invalidateModule(moduleNode);
+    }
+    else {
+        verboseLog("Module not found: id=%s, environment=%s", id, environment);
+    }
+};

package/dist/vite/miniflareHMRPlugin.d.mts

@@ -0,0 +1,8 @@
+import { Plugin } from "vite";
+export declare const miniflareHMRPlugin: (givenOptions: {
+    rootDir: string;
+    viteEnvironment: {
+        name: string;
+    };
+    workerEntryPathname: string;
+}) => (Plugin | Plugin[])[];

package/dist/vite/miniflareHMRPlugin.mjs

@@ -0,0 +1,133 @@
+import { resolve } from "node:path";
+import colors from "picocolors";
+import { readFile } from "node:fs/promises";
+import { getShortName } from "../lib/getShortName.mjs";
+import { pathExists } from "fs-extra";
+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;
+};
+// Cache for "use client" status results
+const useClientCache = new Map();
+// Function to invalidate cache for a file
+const invalidateUseClientCache = (file) => {
+    useClientCache.delete(file);
+};
+const isUseClientModule = async (ctx, file, seen = new Set()) => {
+    // Prevent infinite recursion
+    if (seen.has(file))
+        return false;
+    seen.add(file);
+    try {
+        // Check cache first
+        if (useClientCache.has(file)) {
+            return useClientCache.get(file);
+        }
+        // Read and check the file
+        const content = (await pathExists(file))
+            ? await readFile(file, "utf-8")
+            : "";
+        const hasUseClient = content.includes("'use client'") || content.includes('"use client"');
+        if (hasUseClient) {
+            useClientCache.set(file, true);
+            return true;
+        }
+        // Get the module from the module graph to find importers
+        const module = ctx.server.moduleGraph.getModuleById(file);
+        if (!module) {
+            useClientCache.set(file, false);
+            return false;
+        }
+        // Check all importers recursively
+        for (const importer of module.importers) {
+            if (await isUseClientModule(ctx, importer.url, seen)) {
+                useClientCache.set(file, true);
+                return true;
+            }
+        }
+        useClientCache.set(file, false);
+        return false;
+    }
+    catch (error) {
+        useClientCache.set(file, false);
+        return false;
+    }
+};
+export const miniflareHMRPlugin = (givenOptions) => [
+    {
+        name: "rwsdk:miniflare-hmr",
+        async hotUpdate(ctx) {
+            const environment = givenOptions.viteEnvironment.name;
+            const entry = givenOptions.workerEntryPathname;
+            if (!["client", environment].includes(this.environment.name)) {
+                return;
+            }
+            // todo(justinvdm, 12 Dec 2024): Skip client references
+            const modules = Array.from(ctx.server.environments[environment].moduleGraph.getModulesByFile(ctx.file) ?? []);
+            const isWorkerUpdate = ctx.file === entry ||
+                modules.some((module) => hasEntryAsAncestor(module, entry));
+            // The worker doesnt need an update
+            // => Short circuit HMR
+            if (!isWorkerUpdate) {
+                return [];
+            }
+            // 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") {
+                const cssModules = [];
+                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);
+                        if (clientModules) {
+                            cssModules.push(...clientModules.values());
+                        }
+                    }
+                }
+                invalidateUseClientCache(ctx.file);
+                return (await isUseClientModule(ctx, ctx.file))
+                    ? [...ctx.modules, ...cssModules]
+                    : cssModules;
+            }
+            // 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) {
+                    ctx.server.environments.client.moduleGraph.invalidateModule(m, new Set(), ctx.timestamp, true);
+                }
+                ctx.server.environments.client.hot.send({
+                    type: "custom",
+                    event: "rsc:update",
+                    data: {
+                        file: ctx.file,
+                    },
+                });
+                return [];
+            }
+        },
+    },
+];

package/dist/vite/normalizeModulePath.mjs

@@ -1,2 +1,13 @@
 import path from "node:path";
-export const normalizeModulePath = (projectRootDir, modulePath) => "/" + path.relative(projectRootDir, modulePath);
+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/reactConditionsResolverPlugin.d.mts

@@ -13,4 +13,4 @@ export declare const ENV_RESOLVERS: {
 export declare const ENV_IMPORT_MAPPINGS: {
     [k: string]: Map<string, string>;
 };
-export declare const reactConditionsResolverPlugin: () => Promise<Plugin>;
+export declare const reactConditionsResolverPlugin: () => Plugin[];

package/dist/vite/reactConditionsResolverPlugin.mjs

@@ -95,71 +95,76 @@ function createEsbuildResolverPlugin(envName) {
         },
     };
 }
-export const reactConditionsResolverPlugin = async () => {
+export const reactConditionsResolverPlugin = () => {
     log("Initializing react conditions resolver plugin");
     let isBuild = false;
-    return {
-        name: "rwsdk:react-conditions-resolver",
-        enforce: "post",
-        config(config, { command }) {
-            isBuild = command === "build";
-            log("Configuring plugin for command=%s", command);
+    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 ?? "production");
+                        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);
+                }
+            },
         },
-        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 = {};
+        {
+            name: "rwsdk:react-conditions-resolver:resolveId",
+            enforce: "pre",
+            async resolveId(id, importer) {
+                if (!isBuild) {
+                    return;
                 }
-                if (!config.environments[envName]) {
-                    config.environments[envName] = {};
+                const envName = this.environment?.name;
+                if (!envName) {
+                    return;
                 }
-                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 ?? "production");
-                    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);
+                verboseLog("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
+                const mappings = ENV_IMPORT_MAPPINGS[envName];
+                if (!mappings) {
+                    verboseLog("No mappings found for environment: %s", envName);
+                    return;
                 }
-                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);
+                const resolved = mappings.get(id);
+                if (resolved) {
+                    log("Resolved %s -> %s for env=%s", id, resolved, envName);
+                    return resolved;
                 }
-                log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
-            }
+                verboseLog("No resolution found for id=%s in env=%s", id, envName);
+            },
         },
-        async resolveId(id, importer) {
-            if (!isBuild) {
-                return;
-            }
-            const envName = this.environment?.name;
-            if (!envName) {
-                return;
-            }
-            verboseLog("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
-            const mappings = ENV_IMPORT_MAPPINGS[envName];
-            if (!mappings) {
-                verboseLog("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;
-            }
-            verboseLog("No resolution found for id=%s in env=%s", id, envName);
-        },
-    };
+    ];
 };