bun-dev-server 0.9.85 → 1.0.0

package/dist/bunServeConfig.d.ts

@@ -5,7 +5,7 @@ export interface BuildEnv {
     finalConfig: BunDevServerConfig;
     destinationPath: string;
     buildCfg: BuildConfig;
-    bunServer: Server;
+    bunServer: Server<any>;
     event: FileChangeInfo<any>;
 }
 export interface BunDevServerConfig extends Partial<BunServeConfig> {

package/dist/bunTSWatcher.d.ts

@@ -1,2 +1,2 @@
 import { type Server } from "bun";
-export declare function startTSWatcher(server: Server, watchDir: URL): Promise<void>;
+export declare function startTSWatcher(server: Server<any>, watchDir: URL): Promise<void>;

package/dist/index.js

@@ -1248,30 +1248,20 @@ var import__ = __toESM(require_eventemitter3(), 1);
 
 // node_modules/p-timeout/index.js
 class TimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
+  name = "TimeoutError";
+  constructor(message, options) {
+    super(message, options);
+    Error.captureStackTrace?.(this, TimeoutError);
   }
 }
-
-class AbortError extends Error {
-  constructor(message) {
-    super();
-    this.name = "AbortError";
-    this.message = message;
-  }
-}
-var getDOMException = (errorMessage) => globalThis.DOMException === undefined ? new AbortError(errorMessage) : new DOMException(errorMessage);
-var getAbortedReason = (signal) => {
-  const reason = signal.reason === undefined ? getDOMException("This operation was aborted.") : signal.reason;
-  return reason instanceof Error ? reason : getDOMException(reason);
-};
+var getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
 function pTimeout(promise, options) {
   const {
     milliseconds,
     fallback,
     message,
-    customTimers = { setTimeout, clearTimeout }
+    customTimers = { setTimeout, clearTimeout },
+    signal
   } = options;
   let timer;
   let abortHandler;
@@ -1279,18 +1269,18 @@ function pTimeout(promise, options) {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    if (options.signal) {
-      const { signal } = options;
-      if (signal.aborted) {
-        reject(getAbortedReason(signal));
-      }
+    if (signal?.aborted) {
+      reject(getAbortedReason(signal));
+      return;
+    }
+    if (signal) {
       abortHandler = () => {
         reject(getAbortedReason(signal));
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
+    promise.then(resolve, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
-      promise.then(resolve, reject);
       return;
     }
     const timeoutError = new TimeoutError;
@@ -1315,18 +1305,11 @@ function pTimeout(promise, options) {
         reject(timeoutError);
       }
     }, milliseconds);
-    (async () => {
-      try {
-        resolve(await promise);
-      } catch (error) {
-        reject(error);
-      }
-    })();
   });
   const cancelablePromise = wrappedPromise.finally(() => {
     cancelablePromise.clear();
-    if (abortHandler && options.signal) {
-      options.signal.removeEventListener("abort", abortHandler);
+    if (abortHandler && signal) {
+      signal.removeEventListener("abort", abortHandler);
     }
   });
   cancelablePromise.clear = () => {
@@ -1357,16 +1340,13 @@ function lowerBound(array, value, comparator) {
 class PriorityQueue {
   #queue = [];
   enqueue(run, options) {
-    options = {
-      priority: 0,
-      ...options
-    };
+    const { priority = 0, id } = options ?? {};
     const element = {
-      priority: options.priority,
-      id: options.id,
+      priority,
+      id,
       run
     };
-    if (this.size === 0 || this.#queue[this.size - 1].priority >= options.priority) {
+    if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
       this.#queue.push(element);
       return;
     }
@@ -1395,12 +1375,15 @@ class PriorityQueue {
 
 // node_modules/p-queue/dist/index.js
 class PQueue extends import__.default {
-  #carryoverConcurrencyCount;
+  #carryoverIntervalCount;
   #isIntervalIgnored;
   #intervalCount = 0;
   #intervalCap;
+  #rateLimitedInInterval = false;
+  #rateLimitFlushScheduled = false;
   #interval;
   #intervalEnd = 0;
+  #lastExecutionTime = 0;
   #intervalId;
   #timeoutId;
   #queue;
@@ -1408,13 +1391,13 @@ class PQueue extends import__.default {
   #pending = 0;
   #concurrency;
   #isPaused;
-  #throwOnTimeout;
   #idAssigner = 1n;
+  #runningTasks = new Map;
   timeout;
   constructor(options) {
     super();
     options = {
-      carryoverConcurrencyCount: false,
+      carryoverIntervalCount: false,
       intervalCap: Number.POSITIVE_INFINITY,
       interval: 0,
       concurrency: Number.POSITIVE_INFINITY,
@@ -1428,16 +1411,19 @@ class PQueue extends import__.default {
     if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
       throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
     }
-    this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
     this.#intervalCap = options.intervalCap;
     this.#interval = options.interval;
     this.#queue = new options.queueClass;
     this.#queueClass = options.queueClass;
     this.concurrency = options.concurrency;
+    if (options.timeout !== undefined && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+    }
     this.timeout = options.timeout;
-    this.#throwOnTimeout = options.throwOnTimeout === true;
     this.#isPaused = options.autoStart === false;
+    this.#setupRateLimitTracking();
   }
   get #doesIntervalAllowAnother() {
     return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
@@ -1447,6 +1433,9 @@ class PQueue extends import__.default {
   }
   #next() {
     this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
     this.#tryToStartAnother();
     this.emit("next");
   }
@@ -1460,46 +1449,70 @@ class PQueue extends import__.default {
     if (this.#intervalId === undefined) {
       const delay = this.#intervalEnd - now;
       if (delay < 0) {
-        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
-      } else {
-        if (this.#timeoutId === undefined) {
-          this.#timeoutId = setTimeout(() => {
-            this.#onResumeInterval();
-          }, delay);
+        if (this.#lastExecutionTime > 0) {
+          const timeSinceLastExecution = now - this.#lastExecutionTime;
+          if (timeSinceLastExecution < this.#interval) {
+            this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
+            return true;
+          }
         }
+        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      } else {
+        this.#createIntervalTimeout(delay);
         return true;
       }
     }
     return false;
   }
+  #createIntervalTimeout(delay) {
+    if (this.#timeoutId !== undefined) {
+      return;
+    }
+    this.#timeoutId = setTimeout(() => {
+      this.#onResumeInterval();
+    }, delay);
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = undefined;
+    }
+  }
+  #clearTimeoutTimer() {
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId);
+      this.#timeoutId = undefined;
+    }
+  }
   #tryToStartAnother() {
     if (this.#queue.size === 0) {
-      if (this.#intervalId) {
-        clearInterval(this.#intervalId);
-      }
-      this.#intervalId = undefined;
+      this.#clearIntervalTimer();
       this.emit("empty");
       if (this.#pending === 0) {
+        this.#clearTimeoutTimer();
         this.emit("idle");
       }
       return false;
     }
+    let taskStarted = false;
     if (!this.#isPaused) {
       const canInitializeInterval = !this.#isIntervalPaused;
       if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
         const job = this.#queue.dequeue();
-        if (!job) {
-          return false;
+        if (!this.#isIntervalIgnored) {
+          this.#intervalCount++;
+          this.#scheduleRateLimitUpdate();
         }
         this.emit("active");
+        this.#lastExecutionTime = Date.now();
         job();
         if (canInitializeInterval) {
           this.#initializeIntervalIfNeeded();
         }
-        return true;
+        taskStarted = true;
       }
     }
-    return false;
+    return taskStarted;
   }
   #initializeIntervalIfNeeded() {
     if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
@@ -1512,11 +1525,11 @@ class PQueue extends import__.default {
   }
   #onInterval() {
     if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-      clearInterval(this.#intervalId);
-      this.#intervalId = undefined;
+      this.#clearIntervalTimer();
     }
-    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     this.#processQueue();
+    this.#scheduleRateLimitUpdate();
   }
   #processQueue() {
     while (this.#tryToStartAnother()) {
@@ -1540,24 +1553,43 @@ class PQueue extends import__.default {
     });
   }
   setPriority(id, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+    }
     this.#queue.setPriority(id, priority);
   }
   async add(function_, options = {}) {
     options.id ??= (this.#idAssigner++).toString();
     options = {
       timeout: this.timeout,
-      throwOnTimeout: this.#throwOnTimeout,
       ...options
     };
     return new Promise((resolve, reject) => {
+      const taskSymbol = Symbol(`task-${options.id}`);
       this.#queue.enqueue(async () => {
         this.#pending++;
-        this.#intervalCount++;
+        this.#runningTasks.set(taskSymbol, {
+          id: options.id,
+          priority: options.priority ?? 0,
+          startTime: Date.now(),
+          timeout: options.timeout
+        });
         try {
-          options.signal?.throwIfAborted();
+          try {
+            options.signal?.throwIfAborted();
+          } catch (error) {
+            if (!this.#isIntervalIgnored) {
+              this.#intervalCount--;
+            }
+            this.#runningTasks.delete(taskSymbol);
+            throw error;
+          }
           let operation = function_({ signal: options.signal });
           if (options.timeout) {
-            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+            operation = pTimeout(Promise.resolve(operation), {
+              milliseconds: options.timeout,
+              message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
+            });
           }
           if (options.signal) {
             operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
@@ -1566,14 +1598,13 @@ class PQueue extends import__.default {
           resolve(result);
           this.emit("completed", result);
         } catch (error) {
-          if (error instanceof TimeoutError && !options.throwOnTimeout) {
-            resolve();
-            return;
-          }
           reject(error);
           this.emit("error", error);
         } finally {
-          this.#next();
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
         }
       }, options);
       this.emit("add");
@@ -1596,6 +1627,7 @@ class PQueue extends import__.default {
   }
   clear() {
     this.#queue = new this.#queueClass;
+    this.#updateRateLimitState();
   }
   async onEmpty() {
     if (this.#queue.size === 0) {
@@ -1615,6 +1647,33 @@ class PQueue extends import__.default {
     }
     await this.#onEvent("idle");
   }
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  async onError() {
+    return new Promise((_resolve, reject) => {
+      const handleError = (error) => {
+        this.off("error", handleError);
+        reject(error);
+      };
+      this.on("error", handleError);
+    });
+  }
   async#onEvent(event, filter) {
     return new Promise((resolve) => {
       const listener = () => {
@@ -1639,6 +1698,46 @@ class PQueue extends import__.default {
   get isPaused() {
     return this.#isPaused;
   }
+  #setupRateLimitTracking() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.on("add", () => {
+      if (this.#queue.size > 0) {
+        this.#scheduleRateLimitUpdate();
+      }
+    });
+    this.on("next", () => {
+      this.#scheduleRateLimitUpdate();
+    });
+  }
+  #scheduleRateLimitUpdate() {
+    if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+      return;
+    }
+    this.#rateLimitFlushScheduled = true;
+    queueMicrotask(() => {
+      this.#rateLimitFlushScheduled = false;
+      this.#updateRateLimitState();
+    });
+  }
+  #updateRateLimitState() {
+    const previous = this.#rateLimitedInInterval;
+    const shouldBeRateLimited = !this.#isIntervalIgnored && this.#intervalCount >= this.#intervalCap && this.#queue.size > 0;
+    if (shouldBeRateLimited !== previous) {
+      this.#rateLimitedInInterval = shouldBeRateLimited;
+      this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+  }
+  get isRateLimited() {
+    return this.#rateLimitedInInterval;
+  }
+  get isSaturated() {
+    return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
 }
 
 // src/server.ts

package/package.json

@@ -24,7 +24,7 @@
   "exports": {
     ".": "./dist/index.js"
   },
-  "version": "0.9.85",
+  "version": "1.0.0",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
@@ -32,15 +32,15 @@
     "build": "bun run ./build.ts"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.20"
+    "@types/bun": "^1.3.0"
   },
   "peerDependencies": {
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.3"
   },
   "dependencies": {
     "@types/ejs": "^3.1.5",
     "ejs": "^3.1.10",
-    "p-queue": "^8.1.0",
+    "p-queue": "^9.0.0",
     "picocolors": "^1.1.1"
   }
 }