react-email 2.1.3 → 2.1.4

package/cli/index.mjs

@@ -13,7 +13,7 @@ import { program } from "commander";
 // package.json
 var package_default = {
   name: "react-email",
-  version: "2.1.3",
+  version: "2.1.4",
   description: "A live preview of your emails right in your browser.",
   bin: {
     email: "./cli/index.js"
@@ -40,7 +40,8 @@ var package_default = {
     node: ">=18.0.0"
   },
   dependencies: {
-    "@babel/parser": "7.24.1",
+    "@babel/core": "7.24.5",
+    "@babel/parser": "7.24.5",
     "@radix-ui/colors": "1.0.1",
     "@radix-ui/react-collapsible": "1.0.3",
     "@radix-ui/react-popover": "1.0.7",
@@ -52,7 +53,6 @@ var package_default = {
     "@types/react-dom": "^18.2.0",
     "@types/webpack": "5.28.5",
     autoprefixer: "10.4.14",
-    "babel-walk": "3.0.0",
     chalk: "4.1.2",
     chokidar: "3.5.3",
     clsx: "2.1.0",
@@ -83,8 +83,9 @@ var package_default = {
     typescript: "5.1.6"
   },
   devDependencies: {
-    "@react-email/components": "0.0.18",
-    "@react-email/render": "0.0.14",
+    "@react-email/components": "0.0.19",
+    "@react-email/render": "0.0.15",
+    "@types/babel__core": "7.20.5",
     "@types/fs-extra": "11.0.1",
     "@types/mime-types": "2.1.4",
     "@types/node": "18.0.0",
@@ -158,33 +159,18 @@ var tree = async (dirPath, depth) => {
 };
 
 // src/cli/utils/preview/hot-reloading/setup-hot-reloading.ts
-import path3 from "path";
+import path6 from "path";
 import { Server as SocketServer } from "socket.io";
 import { watch } from "chokidar";
 import debounce from "debounce";
 
 // src/cli/utils/preview/hot-reloading/create-dependency-graph.ts
-import path2 from "path";
-import { promises as fs2 } from "fs";
+import path5 from "path";
+import { existsSync, promises as fs3, statSync } from "fs";
 
 // src/cli/utils/preview/hot-reloading/get-imported-modules.ts
+import { traverse } from "@babel/core";
 import { parse } from "@babel/parser";
-import * as walk from "babel-walk";
-var importVisitor = walk.simple({
-  ImportDeclaration(node, importedPaths) {
-    importedPaths.push(node.source.value);
-  },
-  CallExpression(node, importedPaths) {
-    if ("name" in node.callee && node.callee.name === "require") {
-      if (node.arguments.length === 1) {
-        const importPathNode = node.arguments[0];
-        if (importPathNode.type === "StringLiteral") {
-          importedPaths.push(importPathNode.value);
-        }
-      }
-    }
-  }
-});
 var getImportedModules = (contents) => {
   const importedPaths = [];
   const parsedContents = parse(contents, {
@@ -193,16 +179,227 @@ var getImportedModules = (contents) => {
     errorRecovery: true,
     plugins: ["jsx", "typescript"]
   });
-  importVisitor(parsedContents, importedPaths);
+  traverse(parsedContents, {
+    ImportDeclaration({ node }) {
+      importedPaths.push(node.source.value);
+    },
+    ExportAllDeclaration({ node }) {
+      importedPaths.push(node.source.value);
+    },
+    ExportNamedDeclaration({ node }) {
+      if (node.source) {
+        importedPaths.push(node.source.value);
+      }
+    },
+    CallExpression({ node }) {
+      if ("name" in node.callee && node.callee.name === "require") {
+        if (node.arguments.length === 1) {
+          const importPathNode = node.arguments[0];
+          if (importPathNode.type === "StringLiteral") {
+            importedPaths.push(importPathNode.value);
+          }
+        }
+      }
+    }
+  });
   return importedPaths;
 };
 
+// src/cli/utils/preview/start-dev-server.ts
+import path4 from "path";
+import http from "http";
+import url from "url";
+import next from "next";
+import ora from "ora";
+import logSymbols from "log-symbols";
+import chalk from "chalk";
+
+// src/cli/utils/close-ora-on-sigint.ts
+var closeOraOnSIGNIT = (spinner) => {
+  process.on("SIGINT", () => {
+    spinner.stop();
+  });
+};
+
+// src/cli/utils/preview/serve-static-file.ts
+import path2 from "path";
+import { promises as fs2 } from "fs";
+import { lookup } from "mime-types";
+var serveStaticFile = async (res, parsedUrl, staticDirRelativePath) => {
+  const staticBaseDir = path2.join(process.cwd(), staticDirRelativePath);
+  const pathname = parsedUrl.pathname;
+  const ext = path2.parse(pathname).ext;
+  let fileAbsolutePath = path2.join(staticBaseDir, pathname);
+  const fileHandle = await fs2.open(fileAbsolutePath, "r");
+  try {
+    const fileData = await fs2.readFile(fileHandle);
+    res.setHeader("Content-type", lookup(ext) || "text/plain");
+    res.end(fileData);
+  } catch (exception) {
+    console.error(
+      `Could not read file at ${fileAbsolutePath} to be served, here's the exception:`,
+      exception
+    );
+    res.statusCode = 500;
+    res.end(
+      `Could not read file to be served! Check your terminal for more information.`
+    );
+  } finally {
+    fileHandle.close();
+  }
+};
+
+// src/cli/utils/preview/get-env-variables-for-preview-app.ts
+import path3 from "path";
+var getEnvVariablesForPreviewApp = (relativePathToEmailsDirectory, cliPackageLocation, cwd) => {
+  return {
+    NEXT_PUBLIC_EMAILS_DIR_RELATIVE_PATH: relativePathToEmailsDirectory,
+    NEXT_PUBLIC_CLI_PACKAGE_LOCATION: cliPackageLocation,
+    NEXT_PUBLIC_OS_PATH_SEPARATOR: path3.sep,
+    NEXT_PUBLIC_USER_PROJECT_LOCATION: cwd
+  };
+};
+
+// src/cli/utils/preview/start-dev-server.ts
+var devServer;
+var safeAsyncServerListen = (server, port) => {
+  return new Promise((resolve) => {
+    server.listen(port, () => {
+      resolve({ portAlreadyInUse: false });
+    });
+    server.on("error", (e) => {
+      if (e.code === "EADDRINUSE") {
+        resolve({ portAlreadyInUse: true });
+      }
+    });
+  });
+};
+var isRunningBuilt = __filename.endsWith(path4.join("cli", "index.js"));
+var cliPacakgeLocation = isRunningBuilt ? path4.resolve(__dirname, "..") : path4.resolve(__dirname, "../../../..");
+var startDevServer = async (emailsDirRelativePath, staticBaseDirRelativePath, port) => {
+  devServer = http.createServer((req, res) => {
+    if (!req.url) {
+      res.end(404);
+      return;
+    }
+    const parsedUrl = url.parse(req.url, true);
+    res.setHeader(
+      "Cache-Control",
+      "no-cache, max-age=0, must-revalidate, no-store"
+    );
+    res.setHeader("Pragma", "no-cache");
+    res.setHeader("Expires", "-1");
+    try {
+      if (parsedUrl.path && parsedUrl.path.includes("static/") && !parsedUrl.path.includes("_next/static/")) {
+        void serveStaticFile(res, parsedUrl, staticBaseDirRelativePath);
+      } else if (!isNextReady) {
+        void nextReadyPromise.then(
+          () => nextHandleRequest?.(req, res, parsedUrl)
+        );
+      } else {
+        void nextHandleRequest?.(req, res, parsedUrl);
+      }
+    } catch (e) {
+      console.error("caught error", e);
+      res.writeHead(500);
+      res.end();
+    }
+  });
+  const { portAlreadyInUse } = await safeAsyncServerListen(devServer, port);
+  if (!portAlreadyInUse) {
+    console.log(chalk.greenBright(`    React Email ${package_default.version}`));
+    console.log(`    Running preview at:          http://localhost:${port}
+`);
+  } else {
+    const nextPortToTry = port + 1;
+    console.warn(
+      ` ${logSymbols.warning} Port ${port} is already in use, trying ${nextPortToTry}`
+    );
+    return startDevServer(
+      emailsDirRelativePath,
+      staticBaseDirRelativePath,
+      nextPortToTry
+    );
+  }
+  devServer.on("close", async () => {
+    await app.close();
+  });
+  devServer.on("error", (e) => {
+    console.error(
+      ` ${logSymbols.error} preview server error: `,
+      JSON.stringify(e)
+    );
+    process.exit(1);
+  });
+  const spinner = ora({
+    text: "Getting react-email preview server ready...\n",
+    prefixText: " "
+  }).start();
+  closeOraOnSIGNIT(spinner);
+  const timeBeforeNextReady = performance.now();
+  process.env = {
+    ...process.env,
+    ...getEnvVariablesForPreviewApp(
+      // If we don't do normalization here, stuff like https://github.com/resend/react-email/issues/1354 happens.
+      path4.normalize(emailsDirRelativePath),
+      cliPacakgeLocation,
+      process.cwd()
+    )
+  };
+  const app = next({
+    // passing in env here does not get the environment variables there
+    dev: true,
+    hostname: "localhost",
+    port,
+    dir: cliPacakgeLocation
+  });
+  let isNextReady = false;
+  const nextReadyPromise = app.prepare();
+  await nextReadyPromise;
+  isNextReady = true;
+  const nextHandleRequest = app.getRequestHandler();
+  const secondsToNextReady = ((performance.now() - timeBeforeNextReady) / 1e3).toFixed(1);
+  spinner.stopAndPersist({
+    text: `Ready in ${secondsToNextReady}s
+`,
+    symbol: logSymbols.success
+  });
+  return devServer;
+};
+var makeExitHandler = (options) => (_codeOrSignal) => {
+  if (typeof devServer !== "undefined") {
+    console.log("\nshutting down dev server");
+    devServer.close();
+    devServer = void 0;
+  }
+  if (options?.shouldKillProcess) {
+    process.exit(options.killWithErrorCode ? 1 : 0);
+  }
+};
+process.on("exit", makeExitHandler());
+process.on(
+  "SIGINT",
+  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
+);
+process.on(
+  "SIGUSR1",
+  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
+);
+process.on(
+  "SIGUSR2",
+  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
+);
+process.on(
+  "uncaughtException",
+  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: true })
+);
+
 // src/cli/utils/preview/hot-reloading/create-dependency-graph.ts
 var readAllFilesInsideDirectory = async (directory) => {
   let allFilePaths = [];
-  const topLevelDirents = await fs2.readdir(directory, { withFileTypes: true });
+  const topLevelDirents = await fs3.readdir(directory, { withFileTypes: true });
   for await (const dirent of topLevelDirents) {
-    const pathToDirent = path2.join(directory, dirent.name);
+    const pathToDirent = path5.join(directory, dirent.name);
     if (dirent.isDirectory()) {
       allFilePaths = allFilePaths.concat(
         await readAllFilesInsideDirectory(pathToDirent)
@@ -214,9 +411,24 @@ var readAllFilesInsideDirectory = async (directory) => {
   return allFilePaths;
 };
 var isJavascriptModule = (filePath) => {
-  const extensionName = path2.extname(filePath);
+  const extensionName = path5.extname(filePath);
   return [".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"].includes(extensionName);
 };
+var checkFileExtensionsUntilItExists = (pathWithoutExtension) => {
+  if (existsSync(`${pathWithoutExtension}.ts`)) {
+    return `${pathWithoutExtension}.ts`;
+  } else if (existsSync(`${pathWithoutExtension}.tsx`)) {
+    return `${pathWithoutExtension}.tsx`;
+  } else if (existsSync(`${pathWithoutExtension}.js`)) {
+    return `${pathWithoutExtension}.js`;
+  } else if (existsSync(`${pathWithoutExtension}.jsx`)) {
+    return `${pathWithoutExtension}.jsx`;
+  } else if (existsSync(`${pathWithoutExtension}.mjs`)) {
+    return `${pathWithoutExtension}.mjs`;
+  } else if (existsSync(`${pathWithoutExtension}.cjs`)) {
+    return `${pathWithoutExtension}.cjs`;
+  }
+};
 var createDependencyGraph = async (directory) => {
   const filePaths = await readAllFilesInsideDirectory(directory);
   const modulePaths = filePaths.filter(isJavascriptModule);
@@ -232,13 +444,13 @@ var createDependencyGraph = async (directory) => {
     ])
   );
   const getDependencyPaths = async (filePath) => {
-    const contents = await fs2.readFile(filePath, "utf8");
+    const contents = await fs3.readFile(filePath, "utf8");
     const importedPaths = getImportedModules(contents);
     const importedPathsRelativeToDirectory = importedPaths.map(
       (dependencyPath) => {
         const isModulePath = !dependencyPath.startsWith(".");
-        if (!isModulePath && !path2.isAbsolute(dependencyPath)) {
-          let pathToDependencyFromDirectory = path2.resolve(
+        if (!isModulePath && !path5.isAbsolute(dependencyPath)) {
+          let pathToDependencyFromDirectory = path5.resolve(
             /*
                           path.resolve resolves paths differently from what imports on javascript do.
             
@@ -246,13 +458,38 @@ var createDependencyGraph = async (directory) => {
                           would end up going into /path/to/email.tsx/other-email instead of /path/to/other-email which is the
                           one the import is meant to go to
                         */
-            path2.dirname(filePath),
+            path5.dirname(filePath),
             dependencyPath
           );
+          let isDirectory = false;
+          try {
+            isDirectory = statSync(pathToDependencyFromDirectory).isDirectory();
+          } catch (_) {
+          }
+          if (isDirectory) {
+            const pathToSubDirectory = pathToDependencyFromDirectory;
+            const pathWithExtension = checkFileExtensionsUntilItExists(
+              `${pathToSubDirectory}/index`
+            );
+            if (pathWithExtension) {
+              pathToDependencyFromDirectory = pathWithExtension;
+            } else if (!isRunningBuilt) {
+              console.warn(
+                `Could not find index file for directory at ${pathToDependencyFromDirectory}. This is probably going to cause issues with both hot reloading and your code.`
+              );
+            }
+          }
           if (!isJavascriptModule(pathToDependencyFromDirectory)) {
-            pathToDependencyFromDirectory = `${pathToDependencyFromDirectory}${path2.extname(
-              filePath
-            )}`;
+            const pathWithExtension = checkFileExtensionsUntilItExists(
+              pathToDependencyFromDirectory
+            );
+            if (pathWithExtension) {
+              pathToDependencyFromDirectory = pathWithExtension;
+            } else if (!isRunningBuilt) {
+              console.warn(
+                `Could not determine the file extension for the file at ${pathWithExtension}`
+              );
+            }
           }
           return pathToDependencyFromDirectory;
         } else {
@@ -261,10 +498,10 @@ var createDependencyGraph = async (directory) => {
       }
     );
     const moduleDependencies = importedPathsRelativeToDirectory.filter(
-      (dependencyPath) => !dependencyPath.startsWith(".") && !path2.isAbsolute(dependencyPath)
+      (dependencyPath) => !dependencyPath.startsWith(".") && !path5.isAbsolute(dependencyPath)
     );
     const nonNodeModuleImportPathsRelativeToDirectory = importedPathsRelativeToDirectory.filter(
-      (dependencyPath) => dependencyPath.startsWith(".") || path2.isAbsolute(dependencyPath)
+      (dependencyPath) => dependencyPath.startsWith(".") || path5.isAbsolute(dependencyPath)
     );
     return {
       dependencyPaths: nonNodeModuleImportPathsRelativeToDirectory,
@@ -375,7 +612,7 @@ var setupHotreloading = async (devServer2, emailDirRelativePath) => {
   });
   const watcher = watch(emailDirRelativePath, {
     ignoreInitial: true,
-    cwd: path3.resolve(process.cwd()),
+    cwd: path6.resolve(process.cwd()),
     // eslint-disable-next-line prefer-named-capture-group
     ignored: /(^|[/\\])\../
   });
@@ -391,19 +628,31 @@ var setupHotreloading = async (devServer2, emailDirRelativePath) => {
     });
     changes = [];
   }, 150);
-  const absolutePathToEmailsDirectory = path3.resolve(
+  const absolutePathToEmailsDirectory = path6.resolve(
     process.cwd(),
     emailDirRelativePath
   );
   const [dependencyGraph, updateDependencyGraph] = await createDependencyGraph(
     absolutePathToEmailsDirectory
   );
+  const resolveDependentsOf = (pathToChangeTarget) => {
+    const moduleEntry = dependencyGraph[pathToChangeTarget];
+    const dependentPaths = [];
+    if (moduleEntry) {
+      for (const dependentPath of moduleEntry.dependentPaths) {
+        const dependentsOfDependent = resolveDependentsOf(dependentPath);
+        dependentPaths.push(...dependentsOfDependent);
+        dependentPaths.push(dependentPath);
+      }
+    }
+    return dependentPaths;
+  };
   watcher.on("all", async (event, relativePathToChangeTarget) => {
-    const file = relativePathToChangeTarget.split(path3.sep);
+    const file = relativePathToChangeTarget.split(path6.sep);
     if (file.length === 0) {
       return;
     }
-    const pathToChangeTarget = path3.resolve(
+    const pathToChangeTarget = path6.resolve(
       process.cwd(),
       relativePathToChangeTarget
     );
@@ -412,208 +661,17 @@ var setupHotreloading = async (devServer2, emailDirRelativePath) => {
       event,
       filename: relativePathToChangeTarget
     });
-    changes.push(
-      ...(dependencyGraph[pathToChangeTarget]?.dependentPaths ?? []).map(
-        (dependentPath) => ({
-          event: "change",
-          filename: path3.relative(absolutePathToEmailsDirectory, dependentPath)
-        })
-      )
-    );
+    for (const dependentPath of resolveDependentsOf(pathToChangeTarget)) {
+      changes.push({
+        event: "change",
+        filename: path6.relative(absolutePathToEmailsDirectory, dependentPath)
+      });
+    }
     reload();
   });
   return watcher;
 };
 
-// src/cli/utils/preview/start-dev-server.ts
-import path6 from "path";
-import http from "http";
-import url from "url";
-import next from "next";
-import ora from "ora";
-import logSymbols from "log-symbols";
-import chalk from "chalk";
-
-// src/cli/utils/close-ora-on-sigint.ts
-var closeOraOnSIGNIT = (spinner) => {
-  process.on("SIGINT", () => {
-    spinner.stop();
-  });
-};
-
-// src/cli/utils/preview/serve-static-file.ts
-import path4 from "path";
-import { promises as fs3 } from "fs";
-import { lookup } from "mime-types";
-var serveStaticFile = async (res, parsedUrl, staticDirRelativePath) => {
-  const staticBaseDir = path4.join(process.cwd(), staticDirRelativePath);
-  const pathname = parsedUrl.pathname;
-  const ext = path4.parse(pathname).ext;
-  let fileAbsolutePath = path4.join(staticBaseDir, pathname);
-  const fileHandle = await fs3.open(fileAbsolutePath, "r");
-  try {
-    const fileData = await fs3.readFile(fileHandle);
-    res.setHeader("Content-type", lookup(ext) || "text/plain");
-    res.end(fileData);
-  } catch (exception) {
-    console.error(
-      `Could not read file at ${fileAbsolutePath} to be served, here's the exception:`,
-      exception
-    );
-    res.statusCode = 500;
-    res.end(
-      `Could not read file to be served! Check your terminal for more information.`
-    );
-  } finally {
-    fileHandle.close();
-  }
-};
-
-// src/cli/utils/preview/get-env-variables-for-preview-app.ts
-import path5 from "path";
-var getEnvVariablesForPreviewApp = (relativePathToEmailsDirectory, cliPackageLocation, cwd) => {
-  return {
-    NEXT_PUBLIC_EMAILS_DIR_RELATIVE_PATH: relativePathToEmailsDirectory,
-    NEXT_PUBLIC_CLI_PACKAGE_LOCATION: cliPackageLocation,
-    NEXT_PUBLIC_OS_PATH_SEPARATOR: path5.sep,
-    NEXT_PUBLIC_USER_PROJECT_LOCATION: cwd
-  };
-};
-
-// src/cli/utils/preview/start-dev-server.ts
-var devServer;
-var safeAsyncServerListen = (server, port) => {
-  return new Promise((resolve) => {
-    server.listen(port, () => {
-      resolve({ portAlreadyInUse: false });
-    });
-    server.on("error", (e) => {
-      if (e.code === "EADDRINUSE") {
-        resolve({ portAlreadyInUse: true });
-      }
-    });
-  });
-};
-var isRunningBuilt = __filename.endsWith(path6.join("cli", "index.js"));
-var cliPacakgeLocation = isRunningBuilt ? path6.resolve(__dirname, "..") : path6.resolve(__dirname, "../../../..");
-var startDevServer = async (emailsDirRelativePath, staticBaseDirRelativePath, port) => {
-  devServer = http.createServer((req, res) => {
-    if (!req.url) {
-      res.end(404);
-      return;
-    }
-    const parsedUrl = url.parse(req.url, true);
-    res.setHeader(
-      "Cache-Control",
-      "no-cache, max-age=0, must-revalidate, no-store"
-    );
-    res.setHeader("Pragma", "no-cache");
-    res.setHeader("Expires", "-1");
-    try {
-      if (parsedUrl.path && parsedUrl.path.includes("static/") && !parsedUrl.path.includes("_next/static/")) {
-        void serveStaticFile(res, parsedUrl, staticBaseDirRelativePath);
-      } else if (!isNextReady) {
-        void nextReadyPromise.then(
-          () => nextHandleRequest?.(req, res, parsedUrl)
-        );
-      } else {
-        void nextHandleRequest?.(req, res, parsedUrl);
-      }
-    } catch (e) {
-      console.error("caught error", e);
-      res.writeHead(500);
-      res.end();
-    }
-  });
-  const { portAlreadyInUse } = await safeAsyncServerListen(devServer, port);
-  if (!portAlreadyInUse) {
-    console.log(chalk.greenBright(`    React Email ${package_default.version}`));
-    console.log(`    Running preview at:          http://localhost:${port}
-`);
-  } else {
-    const nextPortToTry = port + 1;
-    console.warn(
-      ` ${logSymbols.warning} Port ${port} is already in use, trying ${nextPortToTry}`
-    );
-    return startDevServer(
-      emailsDirRelativePath,
-      staticBaseDirRelativePath,
-      nextPortToTry
-    );
-  }
-  devServer.on("close", async () => {
-    await app.close();
-  });
-  devServer.on("error", (e) => {
-    console.error(
-      ` ${logSymbols.error} preview server error: `,
-      JSON.stringify(e)
-    );
-    process.exit(1);
-  });
-  const spinner = ora({
-    text: "Getting react-email preview server ready...\n",
-    prefixText: " "
-  }).start();
-  closeOraOnSIGNIT(spinner);
-  const timeBeforeNextReady = performance.now();
-  process.env = {
-    ...process.env,
-    ...getEnvVariablesForPreviewApp(
-      // If we don't do normalization here, stuff like https://github.com/resend/react-email/issues/1354 happens.
-      path6.normalize(emailsDirRelativePath),
-      cliPacakgeLocation,
-      process.cwd()
-    )
-  };
-  const app = next({
-    // passing in env here does not get the environment variables there
-    dev: true,
-    hostname: "localhost",
-    port,
-    dir: cliPacakgeLocation
-  });
-  let isNextReady = false;
-  const nextReadyPromise = app.prepare();
-  await nextReadyPromise;
-  isNextReady = true;
-  const nextHandleRequest = app.getRequestHandler();
-  const secondsToNextReady = ((performance.now() - timeBeforeNextReady) / 1e3).toFixed(1);
-  spinner.stopAndPersist({
-    text: `Ready in ${secondsToNextReady}s
-`,
-    symbol: logSymbols.success
-  });
-  return devServer;
-};
-var makeExitHandler = (options) => (_codeOrSignal) => {
-  if (typeof devServer !== "undefined") {
-    console.log("\nshutting down dev server");
-    devServer.close();
-    devServer = void 0;
-  }
-  if (options?.shouldKillProcess) {
-    process.exit(options.killWithErrorCode ? 1 : 0);
-  }
-};
-process.on("exit", makeExitHandler());
-process.on(
-  "SIGINT",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
-);
-process.on(
-  "SIGUSR1",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
-);
-process.on(
-  "SIGUSR2",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
-);
-process.on(
-  "uncaughtException",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: true })
-);
-
 // src/cli/commands/dev.ts
 var dev = async ({ dir: emailsDirRelativePath, port }) => {
   try {
@@ -704,11 +762,18 @@ var getEmailsDirectoryMetadata = async (absolutePathToEmailsDirectory) => {
 // src/utils/render-resolver-esbuild-plugin.ts
 import path8 from "path";
 import { promises as fs6 } from "fs";
+function escapeStringForRegex(string) {
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
 var renderResolver = (emailTemplates) => ({
   name: "render-resolver",
   setup: (b) => {
     b.onLoad(
-      { filter: new RegExp(emailTemplates.join("|")) },
+      {
+        filter: new RegExp(
+          emailTemplates.map((emailPath) => escapeStringForRegex(emailPath)).join("|")
+        )
+      },
       async ({ path: pathToFile }) => {
         return {
           contents: `${await fs6.readFile(pathToFile, "utf8")};