@dmop/puru 0.1.10 → 0.1.11

package/dist/index.cjs

@@ -20,12 +20,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CancelledError: () => CancelledError,
+  Cond: () => Cond,
+  DeadlineExceededError: () => DeadlineExceededError,
   ErrGroup: () => ErrGroup,
   Mutex: () => Mutex,
   Once: () => Once,
+  RWMutex: () => RWMutex,
   Ticker: () => Ticker,
+  Timer: () => Timer,
   WaitGroup: () => WaitGroup,
   after: () => after,
+  background: () => background,
   chan: () => chan,
   configure: () => configure,
   detectCapability: () => detectCapability,
@@ -36,7 +42,11 @@ __export(index_exports, {
   spawn: () => spawn,
   stats: () => stats,
   task: () => task,
-  ticker: () => ticker
+  ticker: () => ticker,
+  withCancel: () => withCancel,
+  withDeadline: () => withDeadline,
+  withTimeout: () => withTimeout,
+  withValue: () => withValue
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -439,6 +449,12 @@ var ChannelImpl = class {
     this.capacity = capacity;
     channelRegistry.set(this._id, this);
   }
+  get len() {
+    return this.buffer.length;
+  }
+  get cap() {
+    return this.capacity;
+  }
   send(value) {
     if (this.closed) {
       return Promise.reject(new Error("send on closed channel"));
@@ -492,6 +508,40 @@ var ChannelImpl = class {
     }
     this.sendQueue = [];
   }
+  sendOnly() {
+    const send = (value) => this.send(value);
+    const close = () => this.close();
+    const getLen = () => this.len;
+    const getCap = () => this.cap;
+    return {
+      send,
+      close,
+      get len() {
+        return getLen();
+      },
+      get cap() {
+        return getCap();
+      }
+    };
+  }
+  recvOnly() {
+    const recv = () => this.recv();
+    const getLen = () => this.len;
+    const getCap = () => this.cap;
+    const getIter = () => this[Symbol.asyncIterator]();
+    return {
+      recv,
+      get len() {
+        return getLen();
+      },
+      get cap() {
+        return getCap();
+      },
+      [Symbol.asyncIterator]() {
+        return getIter();
+      }
+    };
+  }
   async *[Symbol.asyncIterator]() {
     while (true) {
       const value = await this.recv();
@@ -1200,6 +1250,18 @@ function spawn(fn, opts) {
       }
     }
   };
+  const ctx = opts?.ctx;
+  if (ctx) {
+    if (ctx.signal.aborted) {
+      settled = true;
+      rejectFn(ctx.err ?? new DOMException("Task was cancelled", "AbortError"));
+      return {
+        result,
+        cancel: () => {
+        }
+      };
+    }
+  }
   getPool().submit(task2);
   const cancel = () => {
     if (settled) return;
@@ -1207,6 +1269,14 @@ function spawn(fn, opts) {
     getPool().cancelTask(taskId);
     rejectFn(new DOMException("Task was cancelled", "AbortError"));
   };
+  if (ctx) {
+    const onAbort = () => cancel();
+    ctx.signal.addEventListener("abort", onAbort, { once: true });
+    result.then(
+      () => ctx.signal.removeEventListener("abort", onAbort),
+      () => ctx.signal.removeEventListener("abort", onAbort)
+    );
+  }
   return { result, cancel };
 }
 
@@ -1214,6 +1284,17 @@ function spawn(fn, opts) {
 var WaitGroup = class {
   tasks = [];
   controller = new AbortController();
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+    if (ctx) {
+      if (ctx.signal.aborted) {
+        this.controller.abort();
+      } else {
+        ctx.signal.addEventListener("abort", () => this.cancel(), { once: true });
+      }
+    }
+  }
   /**
    * An `AbortSignal` shared across all tasks in this group.
    * Pass it into spawned functions so they can stop early when `cancel()` is called.
@@ -1230,7 +1311,7 @@ var WaitGroup = class {
     if (this.controller.signal.aborted) {
       throw new Error("WaitGroup has been cancelled");
     }
-    const handle = spawn(fn, opts);
+    const handle = spawn(fn, { ...opts, ctx: this.ctx });
     this.tasks.push(handle);
   }
   /**
@@ -1265,22 +1346,71 @@ var ErrGroup = class {
   controller = new AbortController();
   firstError = null;
   hasError = false;
+  ctx;
+  limit = 0;
+  // 0 = unlimited
+  inFlight = 0;
+  waiting = [];
+  constructor(ctx) {
+    this.ctx = ctx;
+    if (ctx) {
+      if (ctx.signal.aborted) {
+        this.controller.abort();
+      } else {
+        ctx.signal.addEventListener("abort", () => this.cancel(), { once: true });
+      }
+    }
+  }
   get signal() {
     return this.controller.signal;
   }
+  /**
+   * Set the maximum number of tasks that can run concurrently.
+   * Like Go's `errgroup.SetLimit()`. Must be called before any `spawn()`.
+   * A value of 0 (default) means unlimited.
+   */
+  setLimit(n) {
+    if (this.tasks.length > 0) {
+      throw new Error("SetLimit must be called before any spawn()");
+    }
+    if (n < 0 || !Number.isInteger(n)) {
+      throw new RangeError("Limit must be a non-negative integer");
+    }
+    this.limit = n;
+  }
   spawn(fn, opts) {
     if (this.controller.signal.aborted) {
       throw new Error("ErrGroup has been cancelled");
     }
-    const handle = spawn(fn, opts);
-    handle.result.catch((err) => {
+    if (this.limit > 0 && this.inFlight >= this.limit) {
+      const result2 = new Promise((resolve) => {
+        this.waiting.push(resolve);
+      }).then(() => this.doSpawn(fn, opts));
+      this.tasks.push({ result: result2, cancel: () => {
+      } });
+      return;
+    }
+    const result = this.doSpawn(fn, opts);
+    this.tasks.push({ result, cancel: () => {
+    } });
+  }
+  doSpawn(fn, opts) {
+    this.inFlight++;
+    const handle = spawn(fn, { ...opts, ctx: this.ctx });
+    const onSettle = () => {
+      this.inFlight--;
+      const next = this.waiting.shift();
+      if (next) next();
+    };
+    handle.result.then(onSettle, (err) => {
+      onSettle();
       if (!this.hasError) {
         this.hasError = true;
         this.firstError = err;
         this.cancel();
       }
     });
-    this.tasks.push(handle);
+    return handle.result;
   }
   async wait() {
     const settled = await Promise.allSettled(this.tasks.map((t) => t.result));
@@ -1336,6 +1466,121 @@ var Mutex = class {
     return this.locked;
   }
 };
+var RWMutex = class {
+  readers = 0;
+  writing = false;
+  readQueue = [];
+  writeQueue = [];
+  async rLock() {
+    if (!this.writing && this.writeQueue.length === 0) {
+      this.readers++;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.readQueue.push(() => {
+        this.readers++;
+        resolve();
+      });
+    });
+  }
+  rUnlock() {
+    if (this.readers <= 0) {
+      throw new Error("Cannot rUnlock a RWMutex that is not read-locked");
+    }
+    this.readers--;
+    if (this.readers === 0) {
+      this.wakeWriter();
+    }
+  }
+  async lock() {
+    if (!this.writing && this.readers === 0) {
+      this.writing = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.writeQueue.push(() => {
+        this.writing = true;
+        resolve();
+      });
+    });
+  }
+  unlock() {
+    if (!this.writing) {
+      throw new Error("Cannot unlock a RWMutex that is not write-locked");
+    }
+    this.writing = false;
+    if (this.readQueue.length > 0) {
+      this.wakeReaders();
+    } else {
+      this.wakeWriter();
+    }
+  }
+  async withRLock(fn) {
+    await this.rLock();
+    try {
+      return await fn();
+    } finally {
+      this.rUnlock();
+    }
+  }
+  async withLock(fn) {
+    await this.lock();
+    try {
+      return await fn();
+    } finally {
+      this.unlock();
+    }
+  }
+  get isLocked() {
+    return this.writing || this.readers > 0;
+  }
+  wakeReaders() {
+    const queue = this.readQueue;
+    this.readQueue = [];
+    for (const wake of queue) {
+      wake();
+    }
+  }
+  wakeWriter() {
+    const next = this.writeQueue.shift();
+    if (next) next();
+  }
+};
+
+// src/cond.ts
+var Cond = class {
+  mu;
+  waiters = [];
+  constructor(mu) {
+    this.mu = mu;
+  }
+  /**
+   * Atomically releases the mutex, suspends the caller until `signal()` or `broadcast()`
+   * is called, then re-acquires the mutex before returning.
+   *
+   * Must be called while holding the mutex.
+   */
+  async wait() {
+    this.mu.unlock();
+    await new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+    await this.mu.lock();
+  }
+  /** Wake one waiting task (if any). */
+  signal() {
+    const next = this.waiters.shift();
+    if (next) next();
+  }
+  /** Wake all waiting tasks. */
+  broadcast() {
+    const queue = this.waiters;
+    this.waiters = [];
+    for (const wake of queue) {
+      wake();
+    }
+  }
+};
 
 // src/once.ts
 var Once = class {
@@ -1374,6 +1619,7 @@ function select(cases, opts) {
             if (settled) return;
             settled = true;
             try {
+              ;
               handler(value);
               resolve();
             } catch (err) {
@@ -1407,6 +1653,7 @@ function select(cases, opts) {
           if (settled) return;
           settled = true;
           try {
+            ;
             handler(value);
             resolve();
           } catch (err) {
@@ -1477,11 +1724,60 @@ function ticker(ms) {
   return new Ticker(ms);
 }
 
+// src/timer.ts
+var Timer = class {
+  timer = null;
+  _stopped = false;
+  /** Promise that resolves when the timer fires. Replaced on `reset()`. */
+  channel;
+  constructor(ms) {
+    this.channel = this.schedule(ms);
+  }
+  schedule(ms) {
+    return new Promise((resolve) => {
+      this.timer = setTimeout(() => {
+        this._stopped = true;
+        this.timer = null;
+        resolve();
+      }, ms);
+      if (typeof this.timer === "object" && "unref" in this.timer) {
+        this.timer.unref();
+      }
+    });
+  }
+  /**
+   * Stop the timer. Returns `true` if the timer was pending (stopped before firing),
+   * `false` if it had already fired or was already stopped.
+   *
+   * After stopping, the current `channel` promise will never resolve.
+   */
+  stop() {
+    if (this.timer === null) return false;
+    clearTimeout(this.timer);
+    this.timer = null;
+    this._stopped = true;
+    return true;
+  }
+  /**
+   * Reset the timer to fire after `ms` milliseconds.
+   * If the timer was pending, it is stopped first. Creates a new `channel` promise.
+   */
+  reset(ms) {
+    this.stop();
+    this._stopped = false;
+    this.channel = this.schedule(ms);
+  }
+  /** Whether the timer has fired or been stopped. */
+  get stopped() {
+    return this._stopped;
+  }
+};
+
 // src/registry.ts
 var taskCounter2 = 0;
 function task(fn) {
+  const fnStr = serializeFunction(fn);
   return (...args) => {
-    const fnStr = serializeFunction(fn);
     const serializedArgs = args.map((a) => {
       const json = JSON.stringify(a);
       if (json === void 0) {
@@ -1518,14 +1814,179 @@ function task(fn) {
     return result;
   };
 }
+
+// src/context.ts
+var CancelledError = class extends Error {
+  constructor(message = "context cancelled") {
+    super(message);
+    this.name = "CancelledError";
+  }
+};
+var DeadlineExceededError = class extends Error {
+  constructor() {
+    super("context deadline exceeded");
+    this.name = "DeadlineExceededError";
+  }
+};
+var BaseContext = class {
+  _err = null;
+  controller;
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+    this.controller = new AbortController();
+    if (parent) {
+      if (parent.signal.aborted) {
+        this._err = parent.err ?? new CancelledError();
+        this.controller.abort();
+      } else {
+        parent.signal.addEventListener(
+          "abort",
+          () => {
+            if (!this.controller.signal.aborted) {
+              this._err = parent.err ?? new CancelledError();
+              this.controller.abort();
+            }
+          },
+          { once: true }
+        );
+      }
+    }
+  }
+  get signal() {
+    return this.controller.signal;
+  }
+  get deadline() {
+    return this.parent?.deadline ?? null;
+  }
+  get err() {
+    return this._err;
+  }
+  value(_key) {
+    return this.parent?.value(_key);
+  }
+  done() {
+    if (this.controller.signal.aborted) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.controller.signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+  }
+};
+var BackgroundContext = class {
+  _signal = new AbortController().signal;
+  get signal() {
+    return this._signal;
+  }
+  get deadline() {
+    return null;
+  }
+  get err() {
+    return null;
+  }
+  value(_key) {
+    return void 0;
+  }
+  done() {
+    return new Promise(() => {
+    });
+  }
+};
+var bg = null;
+function background() {
+  if (!bg) bg = new BackgroundContext();
+  return bg;
+}
+var CancelContext = class extends BaseContext {
+  cancel(reason) {
+    if (!this.controller.signal.aborted) {
+      this._err = new CancelledError(reason ?? "context cancelled");
+      this.controller.abort();
+    }
+  }
+};
+function withCancel(parent) {
+  const ctx = new CancelContext(parent);
+  return [ctx, (reason) => ctx.cancel(reason)];
+}
+var DeadlineContext = class extends BaseContext {
+  _deadline;
+  timer = null;
+  constructor(parent, deadline) {
+    super(parent);
+    this._deadline = deadline;
+    if (parent.deadline && parent.deadline < deadline) {
+      this._deadline = parent.deadline;
+    }
+    if (this.controller.signal.aborted) {
+      return;
+    }
+    const ms = this._deadline.getTime() - Date.now();
+    if (ms <= 0) {
+      this._err = new DeadlineExceededError();
+      this.controller.abort();
+    } else {
+      this.timer = setTimeout(() => {
+        if (!this.controller.signal.aborted) {
+          this._err = new DeadlineExceededError();
+          this.controller.abort();
+        }
+      }, ms);
+      if (typeof this.timer === "object" && "unref" in this.timer) {
+        this.timer.unref();
+      }
+    }
+  }
+  get deadline() {
+    return this._deadline;
+  }
+  cancel(reason) {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (!this.controller.signal.aborted) {
+      this._err = new CancelledError(reason ?? "context cancelled");
+      this.controller.abort();
+    }
+  }
+};
+function withDeadline(parent, deadline) {
+  const ctx = new DeadlineContext(parent, deadline);
+  return [ctx, (reason) => ctx.cancel(reason)];
+}
+function withTimeout(parent, ms) {
+  return withDeadline(parent, new Date(Date.now() + ms));
+}
+var ValueContext = class extends BaseContext {
+  key;
+  val;
+  constructor(parent, key, val) {
+    super(parent);
+    this.key = key;
+    this.val = val;
+  }
+  value(key) {
+    if (key === this.key) return this.val;
+    return this.parent?.value(key);
+  }
+};
+function withValue(parent, key, value) {
+  return new ValueContext(parent, key, value);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CancelledError,
+  Cond,
+  DeadlineExceededError,
   ErrGroup,
   Mutex,
   Once,
+  RWMutex,
   Ticker,
+  Timer,
   WaitGroup,
   after,
+  background,
   chan,
   configure,
   detectCapability,
@@ -1536,6 +1997,10 @@ function task(fn) {
   spawn,
   stats,
   task,
-  ticker
+  ticker,
+  withCancel,
+  withDeadline,
+  withTimeout,
+  withValue
 });
 //# sourceMappingURL=index.cjs.map