@ls-stack/utils 3.6.0 → 3.8.0

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/testUtils.js

@@ -8,7 +8,7 @@ import {
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-5JQGMNNY.js";
+} from "./chunk-XMUFRC2U.js";
 import {
   clampMin
 } from "./chunk-HTCYUMDR.js";

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.6.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",