bun-dev-server 0.9.81 → 0.9.82

package/dist/bunServeConfig.d.ts

@@ -124,6 +124,30 @@ export interface BunDevServerConfig extends Partial<BunServeConfig> {
     * @param env Supplied environment for the build
     */
     afterBuild?: (output: BuildOutput, env: BuildEnv) => void;
+    /**
+     * throttle-debounce library options used internally to limit build execution.
+     */
+    throttleOptions?: {
+        /**
+         * Optional, defaults to `false`.
+         * If noTrailing is `true`, callback will only execute every delay milliseconds while the throttled-function is being called.
+         * If noTrailing is `false` or unspecified, callback will be executed one final time after the last throttled-function call.
+         * (After the throttled-function has not been called for delay milliseconds, the internal counter is reset)
+         */
+        noLeading?: boolean;
+        /**
+         * Optional, defaults to `false`.
+         * If noLeading is `false`, the first throttled-function call will execute callback immediately.
+         * If noLeading is `true`, the first the callback execution will be skipped.
+         * It should be noted that callback will never executed if both noLeading = `true` and noTrailing = `true`.
+         */
+        noTrailing?: boolean;
+        /**
+         * If debounceMode is `true` (at begin), schedule clear to execute after delay ms.
+         * If debounceMode is `false` (at end), schedule callback to execute after delay ms.
+         */
+        debounceMode?: boolean;
+    };
 }
 export interface BunServeConfig {
     port: number;

package/dist/index.js

@@ -846,84 +846,6 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
-// node_modules/debounce/index.js
-var require_debounce = __commonJS((exports, module) => {
-  function debounce(function_, wait = 100, options = {}) {
-    if (typeof function_ !== "function") {
-      throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
-    }
-    if (wait < 0) {
-      throw new RangeError("`wait` must not be negative.");
-    }
-    const { immediate } = typeof options === "boolean" ? { immediate: options } : options;
-    let storedContext;
-    let storedArguments;
-    let timeoutId;
-    let timestamp;
-    let result;
-    function run() {
-      const callContext = storedContext;
-      const callArguments = storedArguments;
-      storedContext = undefined;
-      storedArguments = undefined;
-      result = function_.apply(callContext, callArguments);
-      return result;
-    }
-    function later() {
-      const last = Date.now() - timestamp;
-      if (last < wait && last >= 0) {
-        timeoutId = setTimeout(later, wait - last);
-      } else {
-        timeoutId = undefined;
-        if (!immediate) {
-          result = run();
-        }
-      }
-    }
-    const debounced = function(...arguments_) {
-      if (storedContext && this !== storedContext && Object.getPrototypeOf(this) === Object.getPrototypeOf(storedContext)) {
-        throw new Error("Debounced method called with different contexts of the same prototype.");
-      }
-      storedContext = this;
-      storedArguments = arguments_;
-      timestamp = Date.now();
-      const callNow = immediate && !timeoutId;
-      if (!timeoutId) {
-        timeoutId = setTimeout(later, wait);
-      }
-      if (callNow) {
-        result = run();
-      }
-      return result;
-    };
-    Object.defineProperty(debounced, "isPending", {
-      get() {
-        return timeoutId !== undefined;
-      }
-    });
-    debounced.clear = () => {
-      if (!timeoutId) {
-        return;
-      }
-      clearTimeout(timeoutId);
-      timeoutId = undefined;
-    };
-    debounced.flush = () => {
-      if (!timeoutId) {
-        return;
-      }
-      debounced.trigger();
-    };
-    debounced.trigger = () => {
-      result = run();
-      debounced.clear();
-    };
-    return debounced;
-  }
-  exports.debounce = debounce;
-  module.exports = debounce;
-});
-
 // src/server.ts
 var import_ejs = __toESM(require_ejs(), 1);
 var {$: $2 } = globalThis.Bun;
@@ -1142,9 +1064,60 @@ ${errOutput}`);
   return success;
 }
 
+// node_modules/throttle-debounce/esm/index.js
+function throttle(delay, callback, options) {
+  var _ref = options || {}, _ref$noTrailing = _ref.noTrailing, noTrailing = _ref$noTrailing === undefined ? false : _ref$noTrailing, _ref$noLeading = _ref.noLeading, noLeading = _ref$noLeading === undefined ? false : _ref$noLeading, _ref$debounceMode = _ref.debounceMode, debounceMode = _ref$debounceMode === undefined ? undefined : _ref$debounceMode;
+  var timeoutID;
+  var cancelled = false;
+  var lastExec = 0;
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+  }
+  function cancel(options2) {
+    var _ref2 = options2 || {}, _ref2$upcomingOnly = _ref2.upcomingOnly, upcomingOnly = _ref2$upcomingOnly === undefined ? false : _ref2$upcomingOnly;
+    clearExistingTimeout();
+    cancelled = !upcomingOnly;
+  }
+  function wrapper() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0;_key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    var self = this;
+    var elapsed = Date.now() - lastExec;
+    if (cancelled) {
+      return;
+    }
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(self, arguments_);
+    }
+    function clear() {
+      timeoutID = undefined;
+    }
+    if (!noLeading && debounceMode && !timeoutID) {
+      exec();
+    }
+    clearExistingTimeout();
+    if (debounceMode === undefined && elapsed > delay) {
+      if (noLeading) {
+        lastExec = Date.now();
+        if (!noTrailing) {
+          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+        }
+      } else {
+        exec();
+      }
+    } else if (noTrailing !== true) {
+      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+    }
+  }
+  wrapper.cancel = cancel;
+  return wrapper;
+}
+
 // src/server.ts
-var import_debounce = __toESM(require_debounce(), 1);
-var watchDelay = 1000;
 async function startBunDevServer(serverConfig, importMeta) {
   const defaultConfig = {
     port: 3000,
@@ -1154,12 +1127,14 @@ async function startBunDevServer(serverConfig, importMeta) {
     createIndexHTML: true,
     tscConfigPath: resolve(importMeta.dir, "./tsconfig.json"),
     broadcastBuildOutputToConsole: true,
-    broadcastBuildOutputToClient: true
+    broadcastBuildOutputToClient: true,
+    throttleOptions: {
+      noLeading: false,
+      noTrailing: false,
+      debounceMode: undefined
+    }
   };
   const finalConfig = { ...defaultConfig, ...serverConfig };
-  if (finalConfig.watchDelay) {
-    watchDelay = finalConfig.watchDelay;
-  }
   if (serverConfig.tscConfigPath) {
     finalConfig.tscConfigPath = resolve(importMeta.dir, serverConfig.tscConfigPath);
   }
@@ -1241,49 +1216,52 @@ async function startBunDevServer(serverConfig, importMeta) {
       sendPings: true
     }
   });
+  const debouncedbuildAndNotify = getThrottledBuildAndNotify(finalConfig);
   debouncedbuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
   const watcher = watch(srcWatch, { recursive: true });
   for await (const event of watcher) {
     debouncedbuildAndNotify(importMeta, finalConfig, destinationPath, buildCfg, bunServer, event);
   }
 }
-var debouncedbuildAndNotify = import_debounce.default(async (importerMeta, finalConfig, destinationPath, buildCfg, bunServer, event) => {
-  if (finalConfig.cleanServePath) {
-    await cleanDirectory(destinationPath);
-  }
-  const buildEnv = {
-    importerMeta,
-    finalConfig,
-    destinationPath,
-    buildCfg,
-    bunServer,
-    event
-  };
-  finalConfig.beforeBuild?.(buildEnv);
-  try {
-    const output = await Bun.build(buildCfg);
-    publishOutputLogs(bunServer, output, finalConfig, event);
-    if (finalConfig.createIndexHTML) {
-      publishIndexHTML(destinationPath, finalConfig.serveIndexHtmlEjs, output, event);
+function getThrottledBuildAndNotify(serverConfig) {
+  return throttle(serverConfig.watchDelay ?? 1000, async (importerMeta, finalConfig, destinationPath, buildCfg, bunServer, event) => {
+    if (finalConfig.cleanServePath) {
+      await cleanDirectory(destinationPath);
     }
-    if (finalConfig.writeManifest) {
-      writeManifest(output, destinationPath, finalConfig.manifestWithHash, finalConfig.manifestName);
-    }
-    finalConfig.afterBuild?.(output, buildEnv);
-    if (finalConfig.reloadOnChange && !finalConfig.waitForTSCSuccessBeforeReload) {
-      bunServer.publish("message", JSON.stringify({ type: "reload" }));
-    }
-    const tscSuccess = await performTSC(finalConfig, importerMeta);
-    if (finalConfig.reloadOnChange && finalConfig.waitForTSCSuccessBeforeReload && !tscSuccess.error) {
-      bunServer.publish("message", JSON.stringify({ type: "reload" }));
-    }
-    if (tscSuccess.error && finalConfig.broadcastTSCErrorToClient) {
-      bunServer.publish("message", JSON.stringify({ type: "tscerror", message: tscSuccess.message }));
+    const buildEnv = {
+      importerMeta,
+      finalConfig,
+      destinationPath,
+      buildCfg,
+      bunServer,
+      event
+    };
+    finalConfig.beforeBuild?.(buildEnv);
+    try {
+      const output = await Bun.build(buildCfg);
+      publishOutputLogs(bunServer, output, finalConfig, event);
+      if (finalConfig.createIndexHTML) {
+        publishIndexHTML(destinationPath, finalConfig.serveIndexHtmlEjs, output, event);
+      }
+      if (finalConfig.writeManifest) {
+        writeManifest(output, destinationPath, finalConfig.manifestWithHash, finalConfig.manifestName);
+      }
+      finalConfig.afterBuild?.(output, buildEnv);
+      if (finalConfig.reloadOnChange && !finalConfig.waitForTSCSuccessBeforeReload) {
+        bunServer.publish("message", JSON.stringify({ type: "reload" }));
+      }
+      const tscSuccess = await performTSC(finalConfig, importerMeta);
+      if (finalConfig.reloadOnChange && finalConfig.waitForTSCSuccessBeforeReload && !tscSuccess.error) {
+        bunServer.publish("message", JSON.stringify({ type: "reload" }));
+      }
+      if (tscSuccess.error && finalConfig.broadcastTSCErrorToClient) {
+        bunServer.publish("message", JSON.stringify({ type: "tscerror", message: tscSuccess.message }));
+      }
+    } catch (e) {
+      console.error(e);
     }
-  } catch (e) {
-    console.error(e);
-  }
-}, watchDelay, { immediate: true });
+  }, serverConfig.throttleOptions);
+}
 function handleErrorResponse(req, err) {
   const msg = `Error while processing request ${req.url}`;
   console.error(msg, err);

package/package.json

@@ -24,7 +24,7 @@
   "exports": {
     ".": "./dist/index.js"
   },
-  "version": "0.9.81",
+  "version": "0.9.82",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
@@ -32,14 +32,15 @@
     "build": "bun run ./build.ts"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.7"
+    "@types/bun": "^1.2.8",
+    "@types/throttle-debounce": "^5.0.2",
+    "throttle-debounce": "^5.0.2"
   },
   "peerDependencies": {
     "typescript": "^5.8.2"
   },
   "dependencies": {
     "@types/ejs": "^3.1.5",
-    "debounce": "^2.2.0",
     "ejs": "^3.1.10",
     "picocolors": "^1.1.1"
   }