@ls-stack/utils 3.7.0 → 3.8.0

package/lib/asyncQueue.cjs

@@ -0,0 +1,239 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/asyncQueue.ts
+var asyncQueue_exports = {};
+__export(asyncQueue_exports, {
+  createAsyncQueue: () => createAsyncQueue,
+  createAsyncQueueWithId: () => createAsyncQueueWithId
+});
+module.exports = __toCommonJS(asyncQueue_exports);
+var import_evtmitter = require("evtmitter");
+var import_t_result = require("t-result");
+
+// src/assertions.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value && isFunction(value.then);
+}
+
+// src/promiseUtils.ts
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { resolve, reject, promise };
+}
+
+// src/asyncQueue.ts
+var AsyncQueue = class {
+  #queue = [];
+  #pending = 0;
+  #size = 0;
+  #concurrency;
+  #completed = 0;
+  #failed = 0;
+  #idleResolvers = [];
+  events = (0, import_evtmitter.evtmitter)();
+  #signal;
+  #taskTimeout;
+  constructor({
+    concurrency = 1,
+    signal,
+    timeout: taskTimeout
+  } = {}) {
+    this.#concurrency = concurrency;
+    this.#signal = signal;
+    this.#taskTimeout = taskTimeout;
+  }
+  #enqueue(task) {
+    this.#queue.push(task);
+    this.#size++;
+  }
+  add(fn, options) {
+    const deferred = defer();
+    const taskTimeout = this.#taskTimeout ?? options?.timeout;
+    const task = {
+      run: async (ctx) => {
+        if (isPromise(fn)) {
+          return fn;
+        }
+        return await fn(ctx);
+      },
+      resolve: deferred.resolve,
+      reject: deferred.reject,
+      signal: options?.signal,
+      id: options?.id,
+      timeout: taskTimeout
+    };
+    this.#enqueue(task);
+    this.#processQueue();
+    return deferred.promise;
+  }
+  resultifyAdd(fn, options) {
+    const cb = async (ctx) => {
+      if (isPromise(fn)) {
+        return await fn;
+      }
+      return fn(ctx);
+    };
+    return this.add((ctx) => (0, import_t_result.resultify)(cb(ctx)), options);
+  }
+  async #processQueue() {
+    if (this.#pending >= this.#concurrency || this.#queue.length === 0) {
+      return;
+    }
+    const task = this.#queue.shift();
+    if (!task) {
+      return;
+    }
+    this.#pending++;
+    this.#size--;
+    const signals = [];
+    if (task.signal) {
+      signals.push(task.signal);
+    }
+    if (this.#signal) {
+      signals.push(this.#signal);
+    }
+    if (task.timeout) {
+      signals.push(AbortSignal.timeout(task.timeout));
+    }
+    const signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    let abortListener;
+    const signalAbortPromise = new Promise((_, reject) => {
+      if (signal) {
+        const error = signal.reason instanceof Error ? signal.reason : new DOMException("Aborted", "AbortError");
+        if (signal.aborted) {
+          reject(error);
+          return;
+        }
+        abortListener = () => {
+          reject(error);
+        };
+        signal.addEventListener("abort", abortListener, { once: true });
+      }
+    });
+    try {
+      const taskRunPromise = task.run({ signal, id: task.id });
+      this.events.emit("start", { id: task.id });
+      const result = await Promise.race([taskRunPromise, signalAbortPromise]);
+      if ((0, import_t_result.isResult)(result)) {
+        task.resolve(result);
+        if (result.error) {
+          this.#failed++;
+          this.events.emit("error", { id: task.id, error: result.error });
+        } else {
+          this.#completed++;
+          this.events.emit("complete", { id: task.id, value: result.value });
+        }
+      } else {
+        const error = new Error("Response not a Result");
+        task.resolve(import_t_result.Result.err(error));
+        this.#failed++;
+        this.events.emit("error", {
+          id: task.id,
+          error: (0, import_t_result.unknownToError)(error)
+        });
+      }
+    } catch (error) {
+      task.resolve(import_t_result.Result.err(error));
+      this.#failed++;
+      this.events.emit("error", { id: task.id, error: (0, import_t_result.unknownToError)(error) });
+    } finally {
+      if (signal && abortListener) {
+        signal.removeEventListener("abort", abortListener);
+      }
+      this.#pending--;
+      this.#processQueue();
+      if (this.#pending === 0 && this.#size === 0) {
+        this.#resolveIdleWaiters();
+      }
+    }
+  }
+  #resolveIdleWaiters() {
+    while (this.#idleResolvers.length > 0) {
+      const resolve = this.#idleResolvers.shift();
+      if (resolve) {
+        resolve();
+      }
+    }
+  }
+  async onIdle() {
+    if (this.#pending === 0 && this.#size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.#idleResolvers.push(resolve);
+    });
+  }
+  clear({ resetCounters = true } = {}) {
+    this.#queue = [];
+    this.#size = 0;
+    if (resetCounters) {
+      this.#completed = 0;
+      this.#failed = 0;
+    }
+    if (this.#pending === 0) {
+      this.#resolveIdleWaiters();
+    }
+  }
+  get completed() {
+    return this.#completed;
+  }
+  get failed() {
+    return this.#failed;
+  }
+  get pending() {
+    return this.#pending;
+  }
+  get size() {
+    return this.#size;
+  }
+};
+var AsyncQueueWithId = class extends AsyncQueue {
+  constructor(options) {
+    super(options);
+  }
+  add(fn, options) {
+    return super.add(fn, options);
+  }
+  resultifyAdd(fn, options) {
+    return super.resultifyAdd(fn, options);
+  }
+};
+function createAsyncQueue(options) {
+  return new AsyncQueue(options);
+}
+function createAsyncQueueWithId(options) {
+  return new AsyncQueueWithId(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAsyncQueue,
+  createAsyncQueueWithId
+});

package/lib/asyncQueue.d.cts

@@ -0,0 +1,56 @@
+import * as evtmitter from 'evtmitter';
+import { ResultValidErrors, Result } from 't-result';
+
+type AsyncQueueOptions = {
+    concurrency?: number;
+    signal?: AbortSignal;
+    timeout?: number;
+};
+type AddOptions<I> = {
+    signal?: AbortSignal;
+    timeout?: number;
+    id?: I;
+};
+type RunCtx<I> = {
+    signal?: AbortSignal;
+    id?: I;
+};
+declare class AsyncQueue<T, E extends ResultValidErrors = Error, I = undefined> {
+    #private;
+    events: evtmitter.Emitter<{
+        error: {
+            id: I;
+            error: E | Error;
+        };
+        complete: {
+            id: I;
+            value: T;
+        };
+        start: {
+            id: I;
+        };
+    }>;
+    constructor({ concurrency, signal, timeout: taskTimeout, }?: AsyncQueueOptions);
+    add(fn: ((ctx: RunCtx<I>) => Promise<Result<T, E>> | Result<T, E>) | Promise<Result<T, E>>, options?: AddOptions<I>): Promise<Result<T, E | Error>>;
+    resultifyAdd(fn: ((ctx: RunCtx<I>) => Promise<T> | T) | Promise<T>, options?: AddOptions<I>): Promise<Result<T, E | Error>>;
+    onIdle(): Promise<void>;
+    clear({ resetCounters }?: {
+        resetCounters?: boolean;
+    }): void;
+    get completed(): number;
+    get failed(): number;
+    get pending(): number;
+    get size(): number;
+}
+type AddOptionsWithId<I> = Omit<AddOptions<I>, 'id'> & {
+    id: I;
+};
+declare class AsyncQueueWithId<T, I, E extends ResultValidErrors = Error> extends AsyncQueue<T, E, I> {
+    constructor(options?: AsyncQueueOptions);
+    add(fn: ((ctx: RunCtx<I>) => Promise<Result<T, E>> | Result<T, E>) | Promise<Result<T, E>>, options?: AddOptionsWithId<I>): Promise<Result<T, E | Error>>;
+    resultifyAdd(fn: ((ctx: RunCtx<I>) => Promise<T> | T) | Promise<T>, options?: AddOptionsWithId<I>): Promise<Result<T, E | Error>>;
+}
+declare function createAsyncQueue<T, E extends ResultValidErrors = Error>(options?: AsyncQueueOptions): AsyncQueue<T, E, undefined>;
+declare function createAsyncQueueWithId<T, I, E extends ResultValidErrors = Error>(options?: AsyncQueueOptions): AsyncQueueWithId<T, I, E>;
+
+export { createAsyncQueue, createAsyncQueueWithId };

package/lib/asyncQueue.d.ts

@@ -0,0 +1,56 @@
+import * as evtmitter from 'evtmitter';
+import { ResultValidErrors, Result } from 't-result';
+
+type AsyncQueueOptions = {
+    concurrency?: number;
+    signal?: AbortSignal;
+    timeout?: number;
+};
+type AddOptions<I> = {
+    signal?: AbortSignal;
+    timeout?: number;
+    id?: I;
+};
+type RunCtx<I> = {
+    signal?: AbortSignal;
+    id?: I;
+};
+declare class AsyncQueue<T, E extends ResultValidErrors = Error, I = undefined> {
+    #private;
+    events: evtmitter.Emitter<{
+        error: {
+            id: I;
+            error: E | Error;
+        };
+        complete: {
+            id: I;
+            value: T;
+        };
+        start: {
+            id: I;
+        };
+    }>;
+    constructor({ concurrency, signal, timeout: taskTimeout, }?: AsyncQueueOptions);
+    add(fn: ((ctx: RunCtx<I>) => Promise<Result<T, E>> | Result<T, E>) | Promise<Result<T, E>>, options?: AddOptions<I>): Promise<Result<T, E | Error>>;
+    resultifyAdd(fn: ((ctx: RunCtx<I>) => Promise<T> | T) | Promise<T>, options?: AddOptions<I>): Promise<Result<T, E | Error>>;
+    onIdle(): Promise<void>;
+    clear({ resetCounters }?: {
+        resetCounters?: boolean;
+    }): void;
+    get completed(): number;
+    get failed(): number;
+    get pending(): number;
+    get size(): number;
+}
+type AddOptionsWithId<I> = Omit<AddOptions<I>, 'id'> & {
+    id: I;
+};
+declare class AsyncQueueWithId<T, I, E extends ResultValidErrors = Error> extends AsyncQueue<T, E, I> {
+    constructor(options?: AsyncQueueOptions);
+    add(fn: ((ctx: RunCtx<I>) => Promise<Result<T, E>> | Result<T, E>) | Promise<Result<T, E>>, options?: AddOptionsWithId<I>): Promise<Result<T, E | Error>>;
+    resultifyAdd(fn: ((ctx: RunCtx<I>) => Promise<T> | T) | Promise<T>, options?: AddOptionsWithId<I>): Promise<Result<T, E | Error>>;
+}
+declare function createAsyncQueue<T, E extends ResultValidErrors = Error>(options?: AsyncQueueOptions): AsyncQueue<T, E, undefined>;
+declare function createAsyncQueueWithId<T, I, E extends ResultValidErrors = Error>(options?: AsyncQueueOptions): AsyncQueueWithId<T, I, E>;
+
+export { createAsyncQueue, createAsyncQueueWithId };

package/lib/asyncQueue.js

@@ -0,0 +1,201 @@
+import {
+  defer
+} from "./chunk-DFXNVEH6.js";
+import {
+  isPromise
+} from "./chunk-3XCS7FVO.js";
+
+// src/asyncQueue.ts
+import { evtmitter } from "evtmitter";
+import {
+  isResult,
+  Result,
+  resultify,
+  unknownToError
+} from "t-result";
+var AsyncQueue = class {
+  #queue = [];
+  #pending = 0;
+  #size = 0;
+  #concurrency;
+  #completed = 0;
+  #failed = 0;
+  #idleResolvers = [];
+  events = evtmitter();
+  #signal;
+  #taskTimeout;
+  constructor({
+    concurrency = 1,
+    signal,
+    timeout: taskTimeout
+  } = {}) {
+    this.#concurrency = concurrency;
+    this.#signal = signal;
+    this.#taskTimeout = taskTimeout;
+  }
+  #enqueue(task) {
+    this.#queue.push(task);
+    this.#size++;
+  }
+  add(fn, options) {
+    const deferred = defer();
+    const taskTimeout = this.#taskTimeout ?? options?.timeout;
+    const task = {
+      run: async (ctx) => {
+        if (isPromise(fn)) {
+          return fn;
+        }
+        return await fn(ctx);
+      },
+      resolve: deferred.resolve,
+      reject: deferred.reject,
+      signal: options?.signal,
+      id: options?.id,
+      timeout: taskTimeout
+    };
+    this.#enqueue(task);
+    this.#processQueue();
+    return deferred.promise;
+  }
+  resultifyAdd(fn, options) {
+    const cb = async (ctx) => {
+      if (isPromise(fn)) {
+        return await fn;
+      }
+      return fn(ctx);
+    };
+    return this.add((ctx) => resultify(cb(ctx)), options);
+  }
+  async #processQueue() {
+    if (this.#pending >= this.#concurrency || this.#queue.length === 0) {
+      return;
+    }
+    const task = this.#queue.shift();
+    if (!task) {
+      return;
+    }
+    this.#pending++;
+    this.#size--;
+    const signals = [];
+    if (task.signal) {
+      signals.push(task.signal);
+    }
+    if (this.#signal) {
+      signals.push(this.#signal);
+    }
+    if (task.timeout) {
+      signals.push(AbortSignal.timeout(task.timeout));
+    }
+    const signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    let abortListener;
+    const signalAbortPromise = new Promise((_, reject) => {
+      if (signal) {
+        const error = signal.reason instanceof Error ? signal.reason : new DOMException("Aborted", "AbortError");
+        if (signal.aborted) {
+          reject(error);
+          return;
+        }
+        abortListener = () => {
+          reject(error);
+        };
+        signal.addEventListener("abort", abortListener, { once: true });
+      }
+    });
+    try {
+      const taskRunPromise = task.run({ signal, id: task.id });
+      this.events.emit("start", { id: task.id });
+      const result = await Promise.race([taskRunPromise, signalAbortPromise]);
+      if (isResult(result)) {
+        task.resolve(result);
+        if (result.error) {
+          this.#failed++;
+          this.events.emit("error", { id: task.id, error: result.error });
+        } else {
+          this.#completed++;
+          this.events.emit("complete", { id: task.id, value: result.value });
+        }
+      } else {
+        const error = new Error("Response not a Result");
+        task.resolve(Result.err(error));
+        this.#failed++;
+        this.events.emit("error", {
+          id: task.id,
+          error: unknownToError(error)
+        });
+      }
+    } catch (error) {
+      task.resolve(Result.err(error));
+      this.#failed++;
+      this.events.emit("error", { id: task.id, error: unknownToError(error) });
+    } finally {
+      if (signal && abortListener) {
+        signal.removeEventListener("abort", abortListener);
+      }
+      this.#pending--;
+      this.#processQueue();
+      if (this.#pending === 0 && this.#size === 0) {
+        this.#resolveIdleWaiters();
+      }
+    }
+  }
+  #resolveIdleWaiters() {
+    while (this.#idleResolvers.length > 0) {
+      const resolve = this.#idleResolvers.shift();
+      if (resolve) {
+        resolve();
+      }
+    }
+  }
+  async onIdle() {
+    if (this.#pending === 0 && this.#size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.#idleResolvers.push(resolve);
+    });
+  }
+  clear({ resetCounters = true } = {}) {
+    this.#queue = [];
+    this.#size = 0;
+    if (resetCounters) {
+      this.#completed = 0;
+      this.#failed = 0;
+    }
+    if (this.#pending === 0) {
+      this.#resolveIdleWaiters();
+    }
+  }
+  get completed() {
+    return this.#completed;
+  }
+  get failed() {
+    return this.#failed;
+  }
+  get pending() {
+    return this.#pending;
+  }
+  get size() {
+    return this.#size;
+  }
+};
+var AsyncQueueWithId = class extends AsyncQueue {
+  constructor(options) {
+    super(options);
+  }
+  add(fn, options) {
+    return super.add(fn, options);
+  }
+  resultifyAdd(fn, options) {
+    return super.resultifyAdd(fn, options);
+  }
+};
+function createAsyncQueue(options) {
+  return new AsyncQueue(options);
+}
+function createAsyncQueueWithId(options) {
+  return new AsyncQueueWithId(options);
+}
+export {
+  createAsyncQueue,
+  createAsyncQueueWithId
+};

package/lib/cache.js

@@ -2,10 +2,10 @@ import {
   durationObjToMs
 } from "./chunk-5MNYPLZI.js";
 import "./chunk-HTCYUMDR.js";
+import "./chunk-II4R3VVX.js";
 import {
   isPromise
 } from "./chunk-3XCS7FVO.js";
-import "./chunk-II4R3VVX.js";
 
 // src/cache.ts
 function cachedGetter(getter) {

package/lib/chunk-DFXNVEH6.js

@@ -0,0 +1,14 @@
+// src/promiseUtils.ts
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { resolve, reject, promise };
+}
+
+export {
+  defer
+};

package/lib/concurrentCalls.cjs

@@ -0,0 +1,288 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/concurrentCalls.ts
+var concurrentCalls_exports = {};
+__export(concurrentCalls_exports, {
+  concurrentCalls: () => concurrentCalls,
+  concurrentCallsWithMetadata: () => concurrentCallsWithMetadata
+});
+module.exports = __toCommonJS(concurrentCalls_exports);
+var import_t_result = require("t-result");
+
+// src/assertions.ts
+function invariant(condition, errorMsg = "Invariant violation") {
+  if (!condition) {
+    throw new Error(`Invariant violation: ${errorMsg}`);
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value && isFunction(value.then);
+}
+
+// src/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/concurrentCalls.ts
+var ConcurrentCalls = class {
+  #pendingCalls = [];
+  #alreadyRun = false;
+  add(...calls) {
+    this.#pendingCalls.push(...calls);
+    return this;
+  }
+  resultifyAdd(...calls) {
+    const processedCalls = calls.map((call) => {
+      if (isPromise(call)) {
+        return call.then((value) => import_t_result.Result.ok(value)).catch((err) => import_t_result.Result.err((0, import_t_result.unknownToError)(err)));
+      } else {
+        const originalFn = call;
+        return async () => {
+          try {
+            const valueOrPromise = originalFn();
+            const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+            return import_t_result.Result.ok(value);
+          } catch (err) {
+            return import_t_result.Result.err((0, import_t_result.unknownToError)(err));
+          }
+        };
+      }
+    });
+    const correctlyTypedProcessedCalls = processedCalls;
+    return this.add(...correctlyTypedProcessedCalls);
+  }
+  async runAll({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    try {
+      const asyncResults = await Promise.all(
+        this.#pendingCalls.map(async (fn, i) => {
+          try {
+            const isP = isPromise(fn);
+            if (delayStart) {
+              invariant(
+                !isP,
+                "Delay start is not supported direct promise calls"
+              );
+              await sleep(delayStart(i));
+            }
+            const result = await (isP ? fn : fn());
+            if (!result.ok) throw result.error;
+            return result.value;
+          } catch (exception) {
+            throw (0, import_t_result.unknownToError)(exception);
+          }
+        })
+      );
+      return import_t_result.Result.ok(asyncResults);
+    } catch (exception) {
+      return import_t_result.Result.err((0, import_t_result.unknownToError)(exception));
+    } finally {
+      this.#pendingCalls = [];
+    }
+  }
+  async runAllSettled({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    const total = this.#pendingCalls.length;
+    const settledResults = await Promise.allSettled(
+      this.#pendingCalls.map(async (callOrPromise, i) => {
+        try {
+          const isP = isPromise(callOrPromise);
+          if (delayStart) {
+            invariant(
+              !isP,
+              "Delay start is not supported for direct promise calls"
+            );
+            await sleep(delayStart(i));
+          }
+          const result = await (isP ? callOrPromise : callOrPromise());
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        } catch (exception) {
+          throw (0, import_t_result.unknownToError)(exception);
+        }
+      })
+    );
+    const succeeded = [];
+    const failed = [];
+    for (const settledResult of settledResults) {
+      if (settledResult.status === "fulfilled") {
+        succeeded.push(settledResult.value);
+      } else {
+        failed.push(settledResult.reason);
+      }
+    }
+    const allFailed = failed.length === total;
+    const aggregatedError = failed.length > 0 ? new AggregateError(failed, "One or more calls failed") : null;
+    this.#pendingCalls = [];
+    return {
+      succeeded,
+      failures: failed,
+      allFailed,
+      total,
+      aggregatedError
+    };
+  }
+};
+function concurrentCalls() {
+  return new ConcurrentCalls();
+}
+var ConcurrentCallsWithMetadata = class {
+  #pendingCalls = [];
+  #alreadyRun = false;
+  add(...calls) {
+    invariant(
+      !this.#alreadyRun,
+      "Cannot add calls after execution has started."
+    );
+    this.#pendingCalls.push(...calls);
+    return this;
+  }
+  resultifyAdd(...items) {
+    const processedItems = items.map(({ fn, metadata }) => {
+      const cb = isPromise(fn) ? (0, import_t_result.resultify)(fn) : () => (0, import_t_result.resultify)(async () => {
+        const result = await fn();
+        return result;
+      });
+      return {
+        fn: cb,
+        metadata
+      };
+    });
+    return this.add(...processedItems);
+  }
+  async runAll({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    const currentCalls = [...this.#pendingCalls];
+    this.#pendingCalls = [];
+    try {
+      const successfulResults = [];
+      for (let i = 0; i < currentCalls.length; i++) {
+        const call = currentCalls[i];
+        try {
+          if (delayStart) {
+            await sleep(delayStart(i));
+          }
+          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          if (!result.ok) {
+            throw { metadata: call.metadata, error: result.error };
+          }
+          successfulResults.push({
+            value: result.value,
+            metadata: call.metadata
+          });
+        } catch (exception) {
+          if (typeof exception === "object" && exception !== null && "metadata" in exception && "error" in exception && exception.metadata === call.metadata) {
+            throw exception;
+          } else {
+            throw {
+              metadata: call.metadata,
+              error: (0, import_t_result.unknownToError)(exception)
+            };
+          }
+        }
+      }
+      return import_t_result.Result.ok(successfulResults);
+    } catch (errorPayload) {
+      return import_t_result.Result.err(errorPayload);
+    }
+  }
+  async runAllSettled({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    const currentCalls = [...this.#pendingCalls];
+    this.#pendingCalls = [];
+    const total = currentCalls.length;
+    if (total === 0) {
+      return {
+        succeeded: [],
+        failed: [],
+        results: [],
+        allFailed: false,
+        total: 0,
+        aggregatedError: null
+      };
+    }
+    const settledOutcomes = await Promise.allSettled(
+      currentCalls.map(async (call, i) => {
+        try {
+          if (delayStart) {
+            await sleep(delayStart(i));
+          }
+          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        } catch (innerException) {
+          throw (0, import_t_result.unknownToError)(innerException);
+        }
+      })
+    );
+    const succeededProcessing = [];
+    const failedProcessing = [];
+    const resultsProcessing = [];
+    for (let i = 0; i < settledOutcomes.length; i++) {
+      const outcome = settledOutcomes[i];
+      const { metadata } = currentCalls[i];
+      if (outcome.status === "fulfilled") {
+        const value = outcome.value;
+        succeededProcessing.push({ value, metadata });
+        resultsProcessing.push({ ok: true, value, metadata, error: false });
+      } else {
+        const error = outcome.reason;
+        failedProcessing.push({ error, metadata });
+        resultsProcessing.push({ ok: false, error, metadata });
+      }
+    }
+    const allFailed = failedProcessing.length === total;
+    const aggregatedError = failedProcessing.length > 0 ? new AggregateError(
+      failedProcessing.map((f) => f.error),
+      "One or more calls failed"
+    ) : null;
+    return {
+      succeeded: succeededProcessing,
+      failed: failedProcessing,
+      results: resultsProcessing,
+      allFailed,
+      total,
+      aggregatedError
+    };
+  }
+};
+function concurrentCallsWithMetadata() {
+  return new ConcurrentCallsWithMetadata();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  concurrentCalls,
+  concurrentCallsWithMetadata
+});

package/lib/concurrentCalls.d.cts

@@ -0,0 +1,75 @@
+import { Result } from 't-result';
+
+type ValidMetadata = string | number | boolean | Record<string, unknown>;
+type RunProps = {
+    delayStart?: (index: number) => number;
+};
+type SucceededCall<R, M> = {
+    value: R;
+    metadata: M;
+};
+type FailedCall<M, E extends Error = Error> = {
+    metadata: M;
+    error: E;
+};
+type Action<R, E extends Error> = (() => Promise<Result<R, E>>) | Promise<Result<R, E>>;
+type SettledResultWithMetadata<R, M, E extends Error = Error> = {
+    ok: true;
+    value: R;
+    metadata: M;
+    error: false;
+} | {
+    ok: false;
+    error: E;
+    metadata: M;
+};
+declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
+    #private;
+    add(...calls: Action<R, E>[]): this;
+    resultifyAdd(...calls: (Promise<R> | (() => R) | (() => Promise<R>))[]): this;
+    runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
+    runAllSettled({ delayStart }?: RunProps): Promise<{
+        allFailed: boolean;
+        failures: E[];
+        succeeded: R[];
+        total: number;
+        aggregatedError: AggregateError | null;
+    }>;
+}
+/**
+ * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ *
+ * @template R - The type of the result value.
+ * @template E - The type of the error.
+ */
+declare function concurrentCalls<R = unknown, E extends Error = Error>(): ConcurrentCalls<R, E>;
+declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error> {
+    #private;
+    add(...calls: {
+        fn: Action<R, E>;
+        metadata: M;
+    }[]): this;
+    resultifyAdd(...items: {
+        fn: (() => R) | (() => Promise<R>) | Promise<R>;
+        metadata: M;
+    }[]): this;
+    runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
+    runAllSettled({ delayStart }?: RunProps): Promise<{
+        allFailed: boolean;
+        failed: FailedCall<M, E>[];
+        succeeded: SucceededCall<R, M>[];
+        total: number;
+        results: SettledResultWithMetadata<R, M, E>[];
+        aggregatedError: AggregateError | null;
+    }>;
+}
+/**
+ * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ *
+ * @template M - The type of the call metadata.
+ * @template R - The type of the result value.
+ * @template E - The type of the error from individual Result objects.
+ */
+declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error>(): ConcurrentCallsWithMetadata<M, R, E>;
+
+export { concurrentCalls, concurrentCallsWithMetadata };

package/lib/concurrentCalls.d.ts

@@ -0,0 +1,75 @@
+import { Result } from 't-result';
+
+type ValidMetadata = string | number | boolean | Record<string, unknown>;
+type RunProps = {
+    delayStart?: (index: number) => number;
+};
+type SucceededCall<R, M> = {
+    value: R;
+    metadata: M;
+};
+type FailedCall<M, E extends Error = Error> = {
+    metadata: M;
+    error: E;
+};
+type Action<R, E extends Error> = (() => Promise<Result<R, E>>) | Promise<Result<R, E>>;
+type SettledResultWithMetadata<R, M, E extends Error = Error> = {
+    ok: true;
+    value: R;
+    metadata: M;
+    error: false;
+} | {
+    ok: false;
+    error: E;
+    metadata: M;
+};
+declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
+    #private;
+    add(...calls: Action<R, E>[]): this;
+    resultifyAdd(...calls: (Promise<R> | (() => R) | (() => Promise<R>))[]): this;
+    runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
+    runAllSettled({ delayStart }?: RunProps): Promise<{
+        allFailed: boolean;
+        failures: E[];
+        succeeded: R[];
+        total: number;
+        aggregatedError: AggregateError | null;
+    }>;
+}
+/**
+ * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ *
+ * @template R - The type of the result value.
+ * @template E - The type of the error.
+ */
+declare function concurrentCalls<R = unknown, E extends Error = Error>(): ConcurrentCalls<R, E>;
+declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error> {
+    #private;
+    add(...calls: {
+        fn: Action<R, E>;
+        metadata: M;
+    }[]): this;
+    resultifyAdd(...items: {
+        fn: (() => R) | (() => Promise<R>) | Promise<R>;
+        metadata: M;
+    }[]): this;
+    runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
+    runAllSettled({ delayStart }?: RunProps): Promise<{
+        allFailed: boolean;
+        failed: FailedCall<M, E>[];
+        succeeded: SucceededCall<R, M>[];
+        total: number;
+        results: SettledResultWithMetadata<R, M, E>[];
+        aggregatedError: AggregateError | null;
+    }>;
+}
+/**
+ * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ *
+ * @template M - The type of the call metadata.
+ * @template R - The type of the result value.
+ * @template E - The type of the error from individual Result objects.
+ */
+declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error>(): ConcurrentCallsWithMetadata<M, R, E>;
+
+export { concurrentCalls, concurrentCallsWithMetadata };

package/lib/concurrentCalls.js

@@ -0,0 +1,247 @@
+import {
+  sleep
+} from "./chunk-5DZT3Z5Z.js";
+import {
+  invariant,
+  isPromise
+} from "./chunk-3XCS7FVO.js";
+
+// src/concurrentCalls.ts
+import { Result, resultify, unknownToError } from "t-result";
+var ConcurrentCalls = class {
+  #pendingCalls = [];
+  #alreadyRun = false;
+  add(...calls) {
+    this.#pendingCalls.push(...calls);
+    return this;
+  }
+  resultifyAdd(...calls) {
+    const processedCalls = calls.map((call) => {
+      if (isPromise(call)) {
+        return call.then((value) => Result.ok(value)).catch((err) => Result.err(unknownToError(err)));
+      } else {
+        const originalFn = call;
+        return async () => {
+          try {
+            const valueOrPromise = originalFn();
+            const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+            return Result.ok(value);
+          } catch (err) {
+            return Result.err(unknownToError(err));
+          }
+        };
+      }
+    });
+    const correctlyTypedProcessedCalls = processedCalls;
+    return this.add(...correctlyTypedProcessedCalls);
+  }
+  async runAll({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    try {
+      const asyncResults = await Promise.all(
+        this.#pendingCalls.map(async (fn, i) => {
+          try {
+            const isP = isPromise(fn);
+            if (delayStart) {
+              invariant(
+                !isP,
+                "Delay start is not supported direct promise calls"
+              );
+              await sleep(delayStart(i));
+            }
+            const result = await (isP ? fn : fn());
+            if (!result.ok) throw result.error;
+            return result.value;
+          } catch (exception) {
+            throw unknownToError(exception);
+          }
+        })
+      );
+      return Result.ok(asyncResults);
+    } catch (exception) {
+      return Result.err(unknownToError(exception));
+    } finally {
+      this.#pendingCalls = [];
+    }
+  }
+  async runAllSettled({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    const total = this.#pendingCalls.length;
+    const settledResults = await Promise.allSettled(
+      this.#pendingCalls.map(async (callOrPromise, i) => {
+        try {
+          const isP = isPromise(callOrPromise);
+          if (delayStart) {
+            invariant(
+              !isP,
+              "Delay start is not supported for direct promise calls"
+            );
+            await sleep(delayStart(i));
+          }
+          const result = await (isP ? callOrPromise : callOrPromise());
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        } catch (exception) {
+          throw unknownToError(exception);
+        }
+      })
+    );
+    const succeeded = [];
+    const failed = [];
+    for (const settledResult of settledResults) {
+      if (settledResult.status === "fulfilled") {
+        succeeded.push(settledResult.value);
+      } else {
+        failed.push(settledResult.reason);
+      }
+    }
+    const allFailed = failed.length === total;
+    const aggregatedError = failed.length > 0 ? new AggregateError(failed, "One or more calls failed") : null;
+    this.#pendingCalls = [];
+    return {
+      succeeded,
+      failures: failed,
+      allFailed,
+      total,
+      aggregatedError
+    };
+  }
+};
+function concurrentCalls() {
+  return new ConcurrentCalls();
+}
+var ConcurrentCallsWithMetadata = class {
+  #pendingCalls = [];
+  #alreadyRun = false;
+  add(...calls) {
+    invariant(
+      !this.#alreadyRun,
+      "Cannot add calls after execution has started."
+    );
+    this.#pendingCalls.push(...calls);
+    return this;
+  }
+  resultifyAdd(...items) {
+    const processedItems = items.map(({ fn, metadata }) => {
+      const cb = isPromise(fn) ? resultify(fn) : () => resultify(async () => {
+        const result = await fn();
+        return result;
+      });
+      return {
+        fn: cb,
+        metadata
+      };
+    });
+    return this.add(...processedItems);
+  }
+  async runAll({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    const currentCalls = [...this.#pendingCalls];
+    this.#pendingCalls = [];
+    try {
+      const successfulResults = [];
+      for (let i = 0; i < currentCalls.length; i++) {
+        const call = currentCalls[i];
+        try {
+          if (delayStart) {
+            await sleep(delayStart(i));
+          }
+          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          if (!result.ok) {
+            throw { metadata: call.metadata, error: result.error };
+          }
+          successfulResults.push({
+            value: result.value,
+            metadata: call.metadata
+          });
+        } catch (exception) {
+          if (typeof exception === "object" && exception !== null && "metadata" in exception && "error" in exception && exception.metadata === call.metadata) {
+            throw exception;
+          } else {
+            throw {
+              metadata: call.metadata,
+              error: unknownToError(exception)
+            };
+          }
+        }
+      }
+      return Result.ok(successfulResults);
+    } catch (errorPayload) {
+      return Result.err(errorPayload);
+    }
+  }
+  async runAllSettled({ delayStart } = {}) {
+    invariant(!this.#alreadyRun, "Already run");
+    this.#alreadyRun = true;
+    const currentCalls = [...this.#pendingCalls];
+    this.#pendingCalls = [];
+    const total = currentCalls.length;
+    if (total === 0) {
+      return {
+        succeeded: [],
+        failed: [],
+        results: [],
+        allFailed: false,
+        total: 0,
+        aggregatedError: null
+      };
+    }
+    const settledOutcomes = await Promise.allSettled(
+      currentCalls.map(async (call, i) => {
+        try {
+          if (delayStart) {
+            await sleep(delayStart(i));
+          }
+          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.value;
+        } catch (innerException) {
+          throw unknownToError(innerException);
+        }
+      })
+    );
+    const succeededProcessing = [];
+    const failedProcessing = [];
+    const resultsProcessing = [];
+    for (let i = 0; i < settledOutcomes.length; i++) {
+      const outcome = settledOutcomes[i];
+      const { metadata } = currentCalls[i];
+      if (outcome.status === "fulfilled") {
+        const value = outcome.value;
+        succeededProcessing.push({ value, metadata });
+        resultsProcessing.push({ ok: true, value, metadata, error: false });
+      } else {
+        const error = outcome.reason;
+        failedProcessing.push({ error, metadata });
+        resultsProcessing.push({ ok: false, error, metadata });
+      }
+    }
+    const allFailed = failedProcessing.length === total;
+    const aggregatedError = failedProcessing.length > 0 ? new AggregateError(
+      failedProcessing.map((f) => f.error),
+      "One or more calls failed"
+    ) : null;
+    return {
+      succeeded: succeededProcessing,
+      failed: failedProcessing,
+      results: resultsProcessing,
+      allFailed,
+      total,
+      aggregatedError
+    };
+  }
+};
+function concurrentCallsWithMetadata() {
+  return new ConcurrentCallsWithMetadata();
+}
+export {
+  concurrentCalls,
+  concurrentCallsWithMetadata
+};

package/lib/createThrottleController.js

@@ -5,8 +5,8 @@ import {
   durationObjToMs
 } from "./chunk-5MNYPLZI.js";
 import "./chunk-HTCYUMDR.js";
-import "./chunk-3XCS7FVO.js";
 import "./chunk-II4R3VVX.js";
+import "./chunk-3XCS7FVO.js";
 
 // src/createThrottleController.ts
 function createThrottleController({

package/lib/parallelAsyncCalls.d.cts

@@ -70,6 +70,8 @@ declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = und
  *
  * @template R - The type of the result value.
  * @template M - The type of the call metadata.
+ *
+ * @deprecated Use concurrentAsyncCalls instead.
  */
 declare function parallelAsyncCalls<M extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M, R>;
 

package/lib/parallelAsyncCalls.d.ts

@@ -70,6 +70,8 @@ declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = und
  *
  * @template R - The type of the result value.
  * @template M - The type of the call metadata.
+ *
+ * @deprecated Use concurrentAsyncCalls instead.
  */
 declare function parallelAsyncCalls<M extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M, R>;
 

package/lib/promiseUtils.js

@@ -1,13 +1,6 @@
-// src/promiseUtils.ts
-function defer() {
-  let resolve;
-  let reject;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  return { resolve, reject, promise };
-}
+import {
+  defer
+} from "./chunk-DFXNVEH6.js";
 export {
   defer
 };

package/lib/yamlStringify.js

@@ -1,13 +1,13 @@
 import {
   truncateString
 } from "./chunk-4REIIZQY.js";
-import {
-  bytesToHumanReadable
-} from "./chunk-IATIXMCE.js";
 import {
   isObject,
   isPlainObject
 } from "./chunk-3XCS7FVO.js";
+import {
+  bytesToHumanReadable
+} from "./chunk-IATIXMCE.js";
 
 // src/yamlStringify.ts
 function yamlStringify(obj, {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "license": "MIT",
   "files": [
     "lib"
@@ -26,6 +26,10 @@
       "import": "./lib/assertions.js",
       "require": "./lib/assertions.cjs"
     },
+    "./asyncQueue": {
+      "import": "./lib/asyncQueue.js",
+      "require": "./lib/asyncQueue.cjs"
+    },
     "./cache": {
       "import": "./lib/cache.js",
       "require": "./lib/cache.cjs"
@@ -34,6 +38,10 @@
       "import": "./lib/castValues.js",
       "require": "./lib/castValues.cjs"
     },
+    "./concurrentCalls": {
+      "import": "./lib/concurrentCalls.js",
+      "require": "./lib/concurrentCalls.cjs"
+    },
     "./consoleFmt": {
       "import": "./lib/consoleFmt.js",
       "require": "./lib/consoleFmt.cjs"
@@ -177,7 +185,8 @@
     "vitest": "^3.0.4"
   },
   "dependencies": {
-    "t-result": "^0.2.1"
+    "evtmitter": "^0.3.3",
+    "t-result": "^0.3.0"
   },
   "scripts": {
     "test:ui": "vitest --ui",