@caido-utils/backend 0.6.0 → 1.0.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { sha256 } from "./crypto";
-export { createSignal, pausePool, resumePool, runPool, stopPool } from "./pool";
-export type { PoolCallbacks, PoolConfig, PoolSignal } from "./pool";
+export { Queue } from "./pool";
+export type { PoolCallbacks, PoolConfig } from "./pool";
 export { spawnCommand } from "./process";
 export { getProjectId } from "./project";
 export { Fetch, queryRequests, type FetchOptions, type QueryRequestsOptions, } from "./requests";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { sha256 } from "./crypto/index.js";
-export { createSignal, pausePool, resumePool, runPool, stopPool } from "./pool/index.js";
+export { Queue } from "./pool/index.js";
 export { spawnCommand } from "./process/index.js";
 export { getProjectId } from "./project/index.js";
 export {

package/dist/pool/index.d.ts

@@ -1,2 +1,2 @@
-export { createSignal, pausePool, resumePool, runPool, stopPool } from "./pool";
-export type { PoolCallbacks, PoolConfig, PoolSignal } from "./pool";
+export { Queue } from "./pool";
+export type { PoolCallbacks, PoolConfig } from "./pool";

package/dist/pool/index.js

@@ -1 +1 @@
-export { createSignal, pausePool, resumePool, runPool, stopPool } from "./pool.js";
+export { Queue } from "./pool.js";

package/dist/pool/pool.d.ts

@@ -1,28 +1,33 @@
-export type PoolSignal = {
-    stopped: boolean;
-    paused: boolean;
-};
 export type PoolConfig = {
     concurrency: number;
     delayMs?: number;
 };
 export type PoolCallbacks<TItem> = {
-    onProgress?: (progress: {
-        completed: number;
-        total: number;
-    }) => void;
     onError?: (item: TItem, error: string) => void;
 };
-export declare function createSignal(): PoolSignal;
-export declare function stopPool(signal: PoolSignal): void;
-export declare function pausePool(signal: PoolSignal): void;
-export declare function resumePool(signal: PoolSignal): void;
-export declare function runPool<TItem>(opts: {
-    items: TItem[] | AsyncIterable<TItem>;
-    config: PoolConfig;
-    signal: PoolSignal;
-    run: (item: TItem) => Promise<void>;
-    callbacks?: PoolCallbacks<TItem>;
-}): Promise<{
-    completed: number;
-}>;
+export declare class Queue<TItem> {
+    private items;
+    private config;
+    private run;
+    private callbacks?;
+    private workers;
+    private stopped;
+    private paused;
+    private waiters;
+    private _completed;
+    constructor(config: PoolConfig, run: (item: TItem) => Promise<void>, callbacks?: PoolCallbacks<TItem>);
+    enqueue(items: TItem | TItem[]): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    isRunning(): boolean;
+    isPaused(): boolean;
+    setConcurrency(concurrency: number): void;
+    get pending(): number;
+    get completed(): number;
+    private notify;
+    private waitForItem;
+    private waitForUnpause;
+    private ensureWorkers;
+    private worker;
+}

package/dist/pool/pool.js

@@ -1,85 +1,112 @@
-export function createSignal() {
-  return { stopped: false, paused: false };
-}
-export function stopPool(signal) {
-  signal.stopped = true;
-}
-export function pausePool(signal) {
-  signal.paused = true;
-}
-export function resumePool(signal) {
-  signal.paused = false;
-}
-const PAUSE_POLL_MS = 200;
-const YIELD_EVERY = 10;
-function yieldTick() {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
 function delay(ms) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function waitForUnpause(signal) {
-  if (!signal.paused || signal.stopped) return Promise.resolve();
-  return new Promise((resolve) => {
-    const poll = () => {
-      if (!signal.paused || signal.stopped) {
-        resolve();
-        return;
-      }
-      setTimeout(poll, PAUSE_POLL_MS);
-    };
-    setTimeout(poll, PAUSE_POLL_MS);
-  });
-}
-async function materializeItems(source) {
-  if (Array.isArray(source)) return source;
-  const items = [];
-  for await (const item of source) {
-    items.push(item);
+const PAUSE_POLL_MS = 200;
+export class Queue {
+  items = [];
+  config;
+  run;
+  callbacks;
+  workers = [];
+  stopped = false;
+  paused = false;
+  waiters = [];
+  _completed = 0;
+  constructor(config, run, callbacks) {
+    this.config = config;
+    this.run = run;
+    this.callbacks = callbacks;
   }
-  return items;
-}
-export async function runPool(opts) {
-  const { config, signal, run, callbacks } = opts;
-  const items = await materializeItems(opts.items);
-  const total = items.length;
-  const delayMs = config.delayMs ?? 0;
-  let nextIndex = 0;
-  let completed = 0;
-  async function worker() {
-    let localCount = 0;
-    while (nextIndex < items.length) {
-      if (signal.stopped) return;
-      await waitForUnpause(signal);
-      if (signal.stopped) return;
-      const idx = nextIndex++;
-      const item = items[idx];
-      if (item === void 0) return;
+  enqueue(items) {
+    const toAdd = Array.isArray(items) ? items : [items];
+    this.items.push(...toAdd);
+    this.notify();
+    this.ensureWorkers();
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  stop() {
+    this.stopped = true;
+    this.items = [];
+    this.notify();
+  }
+  isRunning() {
+    return this.workers.length > 0 && !this.stopped;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  setConcurrency(concurrency) {
+    this.config.concurrency = concurrency;
+    this.notify();
+    this.ensureWorkers();
+  }
+  get pending() {
+    return this.items.length;
+  }
+  get completed() {
+    return this._completed;
+  }
+  notify() {
+    const waiters = this.waiters.splice(0);
+    for (const waiter of waiters) {
+      waiter.resolve();
+    }
+  }
+  waitForItem() {
+    return new Promise((resolve) => {
+      this.waiters.push({ resolve });
+    });
+  }
+  async waitForUnpause() {
+    while (this.paused && !this.stopped) {
+      await delay(PAUSE_POLL_MS);
+    }
+  }
+  ensureWorkers() {
+    if (this.stopped) return;
+    const needed = Math.min(
+      this.config.concurrency - this.workers.length,
+      this.items.length
+    );
+    for (let i = 0; i < needed; i++) {
+      const worker = this.worker();
+      this.workers.push(worker);
+      worker.then(() => {
+        const idx = this.workers.indexOf(worker);
+        if (idx !== -1) this.workers.splice(idx, 1);
+      });
+    }
+  }
+  async worker() {
+    const delayMs = this.config.delayMs ?? 0;
+    while (!this.stopped) {
+      await this.waitForUnpause();
+      if (this.stopped) return;
+      if (this.workers.length > this.config.concurrency) return;
+      const item = this.items.shift();
+      if (item === void 0) {
+        await this.waitForItem();
+        if (this.stopped) return;
+        continue;
+      }
       try {
-        await run(item);
-        completed++;
+        await this.run(item);
       } catch (error) {
-        completed++;
-        if (callbacks?.onError) {
+        if (this.callbacks?.onError) {
           const message = error instanceof Error ? error.message : "Unknown error";
-          callbacks.onError(item, message);
+          this.callbacks.onError(item, message);
         }
       }
-      if (callbacks?.onProgress) {
-        callbacks.onProgress({ completed, total });
-      }
-      localCount++;
-      if (localCount % YIELD_EVERY === 0) {
-        await yieldTick();
-      }
+      this._completed++;
       if (delayMs > 0) {
         await delay(delayMs);
       }
     }
   }
-  const workerCount = Math.min(config.concurrency, items.length);
-  const workers = Array.from({ length: workerCount }, () => worker());
-  await Promise.all(workers);
-  return { completed };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caido-utils/backend",
-  "version": "0.6.0",
+  "version": "1.0.0",
   "type": "module",
   "files": [
     "dist"