@ls-stack/utils 3.63.0 → 3.66.0

package/dist/parallelAsyncCalls.d.ts

@@ -1,82 +0,0 @@
-import { Result } from 't-result';
-
-type ValidMetadata = string | number | boolean | Record<string, unknown>;
-type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {
-    metadata: infer M;
-    fn: () => Promise<Result<infer V>>;
-} ? Succeeded<V, M> : never;
-type TupleRunAllFailed<T> = T extends () => Promise<Result<any>> ? {
-    metadata: undefined;
-    error: Error;
-} : T extends {
-    metadata: infer M extends ValidMetadata;
-} ? {
-    metadata: M;
-    error: Error;
-} : never;
-type TupleRunAllSettled<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> | Failed<undefined> : T extends {
-    metadata: infer M;
-    fn: () => Promise<Result<infer V>>;
-} ? Succeeded<V, M> | Failed<M> : never;
-type RunProps = {
-    delayStart?: (index: number) => number;
-};
-type Failed<M> = {
-    metadata: M;
-    error: Error;
-};
-type Succeeded<R, M> = {
-    value: R;
-    metadata: M;
-};
-declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = undefined, R = unknown> {
-    private pendingCalls;
-    alreadyRun: boolean;
-    constructor();
-    add(call: M extends undefined ? () => Promise<Result<R>> : {
-        metadata: M;
-        fn: () => Promise<Result<R>>;
-    }): this;
-    /**
-     * Adds calls return tuples with inferred results
-     *
-     * @param calls
-     */
-    addTuple<T extends (M extends undefined ? () => Promise<Result<R>> : {
-        metadata: M;
-        fn: () => Promise<Result<R>>;
-    })[]>(...calls: T): {
-        runAllSettled: (props?: RunProps) => Promise<{
-            results: {
-                [I in keyof T]: TupleRunAllSettled<T[I]>;
-            };
-            allFailed: boolean;
-        }>;
-        runAll: (props?: RunProps) => Promise<Result<{
-            [I in keyof T]: TupleRunAllSuccess<T[I]>;
-        }, TupleRunAllFailed<T[number]>>>;
-    };
-    runAllSettled({ delayStart }?: RunProps): Promise<{
-        failed: Failed<M>[];
-        succeeded: Succeeded<R, M>[];
-        allFailed: boolean;
-        results: (Failed<M> | Succeeded<R, M>)[];
-    }>;
-    runAll({ delayStart, }?: {
-        delayStart?: (index: number) => number;
-    }): Promise<Result<Succeeded<R, M>[], {
-        metadata: M;
-        error: Error;
-    }>>;
-}
-/**
- * Executes multiple asynchronous calls in parallel and collects the results in
- * a easier to use format.
- *
- * @deprecated Use concurrentAsyncCalls instead.
- * @template R - The type of the result value.
- * @template M - The type of the call metadata.
- */
-declare function parallelAsyncCalls<M extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M, R>;
-
-export { parallelAsyncCalls };

package/dist/parallelAsyncCalls.js

@@ -1,126 +0,0 @@
-import {
-  sleep
-} from "./chunk-5DZT3Z5Z.js";
-import {
-  invariant,
-  isObject
-} from "./chunk-C2SVCIWE.js";
-import "./chunk-JF2MDHOJ.js";
-
-// src/parallelAsyncCalls.ts
-import { Result, unknownToError } from "t-result";
-var ParallelAsyncResultCalls = class {
-  pendingCalls = [];
-  alreadyRun = false;
-  constructor() {
-  }
-  add(call) {
-    this.pendingCalls.push(
-      isObject(call) ? call : { metadata: void 0, fn: call }
-    );
-    return this;
-  }
-  /**
-   * Adds calls return tuples with inferred results
-   *
-   * @param calls
-   */
-  addTuple(...calls) {
-    for (const call of calls) {
-      this.pendingCalls.push(
-        isObject(call) ? call : { metadata: void 0, fn: call }
-      );
-    }
-    return {
-      runAll: this.runAll.bind(this),
-      runAllSettled: this.runAllSettled.bind(this)
-    };
-  }
-  async runAllSettled({ delayStart } = {}) {
-    invariant(!this.alreadyRun, "Already run");
-    const asyncResults = await Promise.allSettled(
-      this.pendingCalls.map(async (call, i) => {
-        try {
-          if (delayStart) {
-            await sleep(delayStart(i));
-          }
-          const result = await call.fn();
-          return { result, callMetadata: call.metadata };
-        } catch (exception) {
-          return {
-            result: Result.unknownToError(exception),
-            callMetadata: call.metadata
-          };
-        }
-      })
-    );
-    const failed = [];
-    const succeeded = [];
-    const results = [];
-    for (const asyncResult of asyncResults) {
-      invariant(asyncResult.status === "fulfilled");
-      const { result, callMetadata } = asyncResult.value;
-      if (result.ok) {
-        const success = { value: result.value, metadata: callMetadata };
-        results.push(success);
-        succeeded.push(success);
-      } else {
-        const fail = { metadata: callMetadata, error: result.error };
-        results.push(fail);
-        failed.push(fail);
-      }
-    }
-    const allFailed = failed.length === this.pendingCalls.length;
-    this.alreadyRun = true;
-    this.pendingCalls = [];
-    return {
-      failed,
-      succeeded,
-      allFailed,
-      results
-    };
-  }
-  async runAll({
-    delayStart
-  } = {}) {
-    invariant(!this.alreadyRun, "Already run");
-    try {
-      const asyncResults = await Promise.all(
-        this.pendingCalls.map(async (call, i) => {
-          try {
-            if (delayStart) {
-              await sleep(delayStart(i));
-            }
-            const result = await call.fn();
-            if (!result.ok) {
-              throw result.error;
-            }
-            return {
-              value: result.value,
-              metadata: call.metadata
-            };
-          } catch (exception) {
-            throw {
-              metadata: call.metadata,
-              error: unknownToError(exception)
-            };
-          }
-        })
-      );
-      return Result.ok(asyncResults);
-    } catch (exception) {
-      return Result.err(
-        exception
-      );
-    } finally {
-      this.alreadyRun = true;
-      this.pendingCalls = [];
-    }
-  }
-};
-function parallelAsyncCalls() {
-  return new ParallelAsyncResultCalls();
-}
-export {
-  parallelAsyncCalls
-};