bun-dev-server 1.0.1 → 1.0.2

package/dist/buildManager.d.ts

@@ -8,13 +8,18 @@ import { type BunDevServerConfig } from "./bunServeConfig";
  * @returns A p-queue instance configured for throttled builds
  */
 export declare function getThrottledBuildQueue(serverConfig: BunDevServerConfig): pqueue;
+export interface BuildEnvPaths {
+    buildDestination: string;
+    serveDestination: string;
+    watchDestination: string;
+}
 /**
  * Build and notify clients about the build result
  * @param importerMeta - The ImportMeta object from the caller
  * @param finalConfig - The final server configuration
- * @param destinationPath - The absolute path to the output directory
+ * @param buildDestination - The absolute path to the output directory
  * @param buildCfg - The build configuration
  * @param bunServer - The Bun server instance
  * @param event - The file change event that triggered the build
  */
-export declare function cleanBuildAndNotify(importerMeta: ImportMeta, finalConfig: BunDevServerConfig, destinationPath: string, buildCfg: BuildConfig, bunServer: Server<any>, event: FileChangeInfo<string>): Promise<void>;
+export declare function cleanBuildAndNotify(importerMeta: ImportMeta, finalConfig: BunDevServerConfig, paths: BuildEnvPaths, buildCfg: BuildConfig, bunServer: Server<any>, event: FileChangeInfo<string>): Promise<void>;

package/dist/bunServeConfig.d.ts

@@ -3,7 +3,9 @@ import type { FileChangeInfo } from "fs/promises";
 export interface BuildEnv {
     importerMeta: ImportMeta;
     finalConfig: BunDevServerConfig;
-    destinationPath: string;
+    buildDestination: string;
+    serveDestination: string;
+    watchDestination: string;
     buildCfg: BuildConfig;
     bunServer: Server<any>;
     event: FileChangeInfo<any>;
@@ -98,6 +100,13 @@ export interface BunDevServerConfig extends Partial<BunServeConfig> {
      * Whether to clean the `servePath` before building a new batch.
      */
     cleanServePath?: boolean;
+    /**
+     * Whether to clean the `outdir` before building a new batch.
+     *
+     * If `outdir` is under `servePath` and `cleanServePath` is true,
+     * then `outdir` will be cleaned regardless.
+     */
+    cleanBuildPath?: boolean;
     /**
      * The EJS template used for the output of the `/` path on the server.
      * When supplying your own template, the properties that are provided during rendering are `files` and `dirs` both are arrays.

package/dist/configManager.d.ts

@@ -5,8 +5,9 @@ import { type BuildConfig } from "bun";
 import { type BunDevServerConfig } from "./bunServeConfig";
 export interface PreparedConfig {
     finalConfig: BunDevServerConfig;
-    destinationPath: string;
-    srcWatch: string;
+    serveDestination: string;
+    buildDestination: string;
+    watchDestination: string;
     buildCfg: BuildConfig;
 }
 /**

package/dist/fileWatcher.d.ts

@@ -1,12 +1,13 @@
 import { type BuildConfig, type Server } from "bun";
 import { type BunDevServerConfig } from "./bunServeConfig";
+import { type BuildEnvPaths } from "./buildManager";
 /**
  * Start watching a directory for changes and trigger builds
  * @param srcWatch - The absolute path to watch for changes
  * @param importMeta - The ImportMeta object from the caller
  * @param finalConfig - The final server configuration
- * @param destinationPath - The absolute path to the output directory
+ * @param buildDestination - The absolute path to the output directory
  * @param buildCfg - The build configuration
  * @param bunServer - The Bun server instance
  */
-export declare function startFileWatcher(srcWatch: string, importMeta: ImportMeta, finalConfig: BunDevServerConfig, destinationPath: string, buildCfg: BuildConfig, bunServer: Server<any>): Promise<void>;
+export declare function startFileWatcher(srcWatch: string, importMeta: ImportMeta, finalConfig: BunDevServerConfig, paths: BuildEnvPaths, buildCfg: BuildConfig, bunServer: Server<any>): Promise<void>;

package/dist/index.js

@@ -1044,6 +1044,15 @@ function withCORSHeaders(response, request) {
 // src/utils/filesystem.ts
 var {$ } = globalThis.Bun;
 import { access, constants } from "fs/promises";
+import { mkdir } from "fs/promises";
+async function ensureDestinationDirectory(destinationPath) {
+  try {
+    await mkdir(destinationPath, { recursive: true });
+  } catch (e) {
+    console.error("Unable to create directory", e);
+    throw e;
+  }
+}
 async function cleanDirectory(dst) {
   const { stderr, exitCode } = await $`rm -rf ${dst}/*`.nothrow();
   if (exitCode !== 0) {
@@ -1496,13 +1505,6 @@ class PQueue extends import__.default {
     this.#concurrency = newConcurrency;
     this.#processQueue();
   }
-  async#throwOnAbort(signal) {
-    return new Promise((_resolve, reject) => {
-      signal.addEventListener("abort", () => {
-        reject(signal.reason);
-      }, { once: true });
-    });
-  }
   setPriority(id, priority) {
     if (typeof priority !== "number" || !Number.isFinite(priority)) {
       throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
@@ -1525,6 +1527,7 @@ class PQueue extends import__.default {
           startTime: Date.now(),
           timeout: options.timeout
         });
+        let eventListener;
         try {
           try {
             options.signal?.throwIfAborted();
@@ -1543,7 +1546,13 @@ class PQueue extends import__.default {
             });
           }
           if (options.signal) {
-            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
+            const { signal } = options;
+            operation = Promise.race([operation, new Promise((_resolve, reject2) => {
+              eventListener = () => {
+                reject2(signal.reason);
+              };
+              signal.addEventListener("abort", eventListener, { once: true });
+            })]);
           }
           const result = await operation;
           resolve2(result);
@@ -1552,6 +1561,9 @@ class PQueue extends import__.default {
           reject(error);
           this.emit("error", error);
         } finally {
+          if (eventListener) {
+            options.signal?.removeEventListener("abort", eventListener);
+          }
           this.#runningTasks.delete(taskSymbol);
           queueMicrotask(() => {
             this.#next();
@@ -1729,7 +1741,7 @@ function writeManifest(output, outdir, withHash = false, manifestName = "bun_ser
   for (const ep of entryPoints) {
     const basePathUrl = pathToFileURL(outdir);
     const epUrl = pathToFileURL(ep.path);
-    const relativePath = epUrl.href.replace(`${basePathUrl.href}/`, "");
+    const relativePath = epUrl.href.replace(`${basePathUrl.href}/`, "./");
     const hashedImport = `${relativePath}${withHash ? `?${ep.hash}` : ``}`;
     epTable.push(hashedImport);
   }
@@ -1746,30 +1758,25 @@ function getThrottledBuildQueue(serverConfig) {
     carryoverConcurrencyCount: true
   });
 }
-async function cleanBuildAndNotify(importerMeta, finalConfig, destinationPath, buildCfg, bunServer, event) {
+async function cleanBuildAndNotify(importerMeta, finalConfig, paths, buildCfg, bunServer, event) {
   const buildEnv = {
     importerMeta,
     finalConfig,
-    destinationPath,
+    ...paths,
     buildCfg,
     bunServer,
     event
   };
   await finalConfig.beforeBuild?.(buildEnv);
   try {
-    if (buildCfg.outdir) {
-      const outdirExists = await checkObjectExists(buildCfg.outdir);
-      if (!outdirExists) {
-        return;
-      }
-    }
+    await ensureDestinationDirectory(paths.buildDestination);
     const output = await build(buildCfg);
     publishOutputLogs(bunServer, output, finalConfig, event);
     if (finalConfig.createIndexHTML) {
-      publishIndexHTML(destinationPath, finalConfig.serveIndexHtmlEjs, output, event);
+      publishIndexHTML(paths, finalConfig.serveIndexHtmlEjs, output, event);
     }
     if (finalConfig.writeManifest) {
-      writeManifest(output, destinationPath, finalConfig.manifestWithHash, finalConfig.manifestName);
+      writeManifest(output, paths.serveDestination, finalConfig.manifestWithHash, finalConfig.manifestName);
     }
     await finalConfig.afterBuild?.(output, buildEnv);
     if (finalConfig.reloadOnChange && !finalConfig.waitForTSCSuccessBeforeReload) {
@@ -1816,23 +1823,23 @@ function publishOutputLogs(bunServer, output, config, event) {
     bunServer.publish("message", JSON.stringify({ type: "output", message: outTable }));
   }
 }
-function publishIndexHTML(destinationPath, template, output, _event) {
+function publishIndexHTML(paths, template, output, _event) {
   const eps = output.outputs.filter((o) => o.kind === "entry-point");
   const hashedImports = [];
   const cssFiles = [];
-  const basePathUrl = Bun.pathToFileURL(destinationPath);
+  const basePathUrl = Bun.pathToFileURL(paths.serveDestination);
   for (const ep of eps) {
     const epUrl = Bun.pathToFileURL(ep.path);
-    const hashedImport = `${epUrl.href.replace(basePathUrl.href, "")}?${ep.hash}`;
+    const hashedImport = `${epUrl.href.replace(`${basePathUrl.href}/`, "./")}?${ep.hash}`;
     hashedImports.push(hashedImport);
   }
   const cssOutputs = output.outputs.filter((o) => o.path.endsWith(".css"));
   for (const cssFile of cssOutputs) {
     const cssUrl = Bun.pathToFileURL(cssFile.path);
-    const hashedCss = `${cssUrl.href.replace(basePathUrl.href, "")}?${cssFile.hash}`;
+    const hashedCss = `${cssUrl.href.replace(`${basePathUrl.href}/`, "./")}?${cssFile.hash}`;
     cssFiles.push(hashedCss);
   }
-  Bun.write(destinationPath + "/index.html", import_ejs2.render(template, { hashedImports, cssFiles }));
+  Bun.write(paths.buildDestination + "/index.html", import_ejs2.render(template, { hashedImports, cssFiles }));
 }
 function printPrettyBuildOutput(outTable) {
   if (outTable.length === 0)
@@ -1851,10 +1858,10 @@ function printPrettyBuildOutput(outTable) {
 }
 
 // src/fileWatcher.ts
-async function startFileWatcher(srcWatch, importMeta, finalConfig, destinationPath, buildCfg, bunServer) {
+async function startFileWatcher(srcWatch, importMeta, finalConfig, paths, buildCfg, bunServer) {
   const queue = getThrottledBuildQueue(finalConfig);
   await queue.add(async () => {
-    await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
+    await cleanBuildAndNotify(importMeta, finalConfig, paths, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
   });
   const watcher = watch(srcWatch, { recursive: true });
   try {
@@ -1867,7 +1874,7 @@ async function startFileWatcher(srcWatch, importMeta, finalConfig, destinationPa
           queue.clear();
         }
         queue.add(async () => {
-          await cleanBuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, event);
+          await cleanBuildAndNotify(importMeta, finalConfig, paths, buildCfg, bunServer, event);
         });
       } catch (e) {
         console.error("Error while processing file change", e);
@@ -1881,8 +1888,6 @@ async function startFileWatcher(srcWatch, importMeta, finalConfig, destinationPa
 }
 
 // src/configManager.ts
-var {$: $3 } = globalThis.Bun;
-import { readdir as readdir2 } from "fs/promises";
 import { resolve as resolve2 } from "path";
 
 // src/templates/output.ejs
@@ -2043,15 +2048,16 @@ async function prepareConfiguration(serverConfig, importMeta) {
   if (!finalConfig.watchDir) {
     throw new Error("watchDir must be set");
   }
-  const servePart = finalConfig.buildConfig.outdir ?? finalConfig.servePath ?? "./dist";
+  const defaultBuildDir = finalConfig.buildConfig.outdir ?? "./dist";
+  const servePart = finalConfig.servePath ?? defaultBuildDir;
   const serveDestination = resolve2(importMeta.dir, servePart);
   const watchDestination = resolve2(importMeta.dir, finalConfig.watchDir);
+  const buildDestination = resolve2(importMeta.dir, defaultBuildDir);
   const allEntries = serverConfig.buildConfig.entrypoints.splice(0, serverConfig.buildConfig.entrypoints.length);
   const resolvedEntries = allEntries.map((e) => resolve2(importMeta.dir, e));
   serverConfig.buildConfig.entrypoints = resolvedEntries;
-  const destinationPath = serveDestination;
-  const srcWatch = watchDestination;
-  await ensureDestinationDirectory(destinationPath);
+  await ensureDestinationDirectory(buildDestination);
+  await ensureDestinationDirectory(serveDestination);
   const buncfg = {
     port: finalConfig.port,
     tls: finalConfig.tls,
@@ -2060,7 +2066,7 @@ async function prepareConfiguration(serverConfig, importMeta) {
   };
   const buildCfg = {
     ...serverConfig.buildConfig,
-    outdir: destinationPath
+    outdir: buildDestination
   };
   if (finalConfig.hotReload === "footer") {
     if (!buildCfg.footer) {
@@ -2076,44 +2082,36 @@ async function prepareConfiguration(serverConfig, importMeta) {
   }
   const userBeforeBuild = finalConfig.beforeBuild;
   finalConfig.beforeBuild = async (env) => {
-    if (serverConfig.cleanServePath) {
-      await cleanDirectory(env.destinationPath);
+    const buildDirOverOfServe = serveDestination.indexOf(buildDestination) !== -1;
+    const serveDirOverOfBuild = buildDestination.indexOf(serveDestination) !== -1;
+    if (serverConfig.cleanBuildPath && buildDirOverOfServe) {
+      await cleanDirectory(env.buildDestination);
+    }
+    if (serverConfig.cleanServePath && serveDirOverOfBuild) {
+      await cleanDirectory(env.serveDestination);
     }
     await userBeforeBuild?.(env);
   };
   return {
     finalConfig,
-    destinationPath,
-    srcWatch,
+    serveDestination,
+    buildDestination,
+    watchDestination,
     buildCfg
   };
 }
-async function ensureDestinationDirectory(destinationPath) {
-  try {
-    await readdir2(destinationPath);
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      console.log("Directory not found, creating it...");
-      try {
-        await $3`mkdir ${destinationPath}`;
-      } catch (e2) {
-        console.error("Unable to create directory", e2);
-      }
-    } else {
-      throw e;
-    }
-  }
-}
 
 // src/server.ts
 async function startBunDevServer(serverConfig, importMeta) {
-  const { finalConfig, destinationPath, srcWatch, buildCfg } = await prepareConfiguration(serverConfig, importMeta);
+  const { finalConfig, buildCfg, ...paths } = await prepareConfiguration(serverConfig, importMeta);
   const protocol = finalConfig.tls ? "https" : "http";
   const serverUrl = `${protocol}://localhost:${finalConfig.port}`;
   const isTestMode = process.env.BUN_TEST === "true" || typeof Bun !== "undefined" && Bun.main.includes("test");
   if (!isTestMode) {
     console.log(import_picocolors3.default.bold(import_picocolors3.default.green("\uD83D\uDE80 Server running at")) + " " + import_picocolors3.default.cyan(import_picocolors3.default.underline(serverUrl)));
+    console.log(import_picocolors3.default.bold(import_picocolors3.default.green("\uD83D\uDCC1 Serving files from")) + " " + import_picocolors3.default.cyan(import_picocolors3.default.underline(paths.serveDestination)));
   }
+  await ensureDestinationDirectory(paths.serveDestination);
   let bunServer;
   try {
     bunServer = Bun.serve({
@@ -2142,7 +2140,7 @@ async function startBunDevServer(serverConfig, importMeta) {
         }
         const url = new URL(req.url);
         let requestPath = url.pathname;
-        return handlePathRequest(requestPath, req, finalConfig, destinationPath);
+        return handlePathRequest(requestPath, req, finalConfig, paths.serveDestination);
       },
       websocket: {
         open(ws) {
@@ -2160,7 +2158,7 @@ async function startBunDevServer(serverConfig, importMeta) {
     throw error;
   }
   if (bunServer) {
-    await startFileWatcher(srcWatch, importMeta, finalConfig, destinationPath, buildCfg, bunServer);
+    await startFileWatcher(paths.watchDestination, importMeta, finalConfig, paths, buildCfg, bunServer);
   }
 }
 export {

package/dist/utils/filesystem.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Ensure the destination directory exists, create if it doesn't
+ * @param destinationPath - The absolute path to the destination directory
+ */
+export declare function ensureDestinationDirectory(destinationPath: string): Promise<void>;
 /**
  * Clean a directory by removing all its contents
  * @param dst - The absolute path to the directory to clean

package/package.json

@@ -24,7 +24,7 @@
   "exports": {
     ".": "./dist/index.js"
   },
-  "version": "1.0.1",
+  "version": "1.0.2",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
@@ -35,7 +35,7 @@
     "test:coverage": "bun test --coverage"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.0"
+    "@types/bun": "^1.3.3"
   },
   "peerDependencies": {
     "typescript": "^5.9.3"
@@ -43,7 +43,7 @@
   "dependencies": {
     "@types/ejs": "^3.1.5",
     "ejs": "^3.1.10",
-    "p-queue": "^9.0.0",
+    "p-queue": "^9.0.1",
     "picocolors": "^1.1.1"
   }
 }