@ls-stack/utils 3.63.0 → 3.66.0

package/dist/concurrentCalls.cjs

@@ -1,406 +0,0 @@
-"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, {
-  ConcurrentCallsAggregateError: () => ConcurrentCallsAggregateError,
-  ConcurrentCallsWithMetadataAggregateError: () => ConcurrentCallsWithMetadataAggregateError,
-  concurrentCalls: () => concurrentCalls,
-  concurrentCallsWithMetadata: () => concurrentCallsWithMetadata,
-  concurrentResultCalls: () => concurrentResultCalls,
-  concurrentResultsWithMetadata: () => concurrentResultsWithMetadata
-});
-module.exports = __toCommonJS(concurrentCalls_exports);
-var import_t_result = require("t-result");
-
-// src/typeGuards.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/assertions.ts
-function invariant(condition, error = "Invariant violation") {
-  if (!condition) {
-    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
-  }
-}
-var isFunction2 = isFunction;
-
-// src/arrayUtils.ts
-function truncateArray(array, maxLength, appendIfTruncated) {
-  const truncate = array.length > maxLength;
-  const result = truncate ? [...array.slice(0, maxLength)] : array;
-  if (truncate && appendIfTruncated) {
-    if (isFunction2(appendIfTruncated)) {
-      return [...result, appendIfTruncated(array.length - maxLength)];
-    }
-    return [...result, appendIfTruncated];
-  }
-  return result;
-}
-
-// src/safeJson.ts
-function safeJsonStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (_) {
-    return void 0;
-  }
-}
-
-// src/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/stringUtils.ts
-function truncateString(str, length, ellipsis = "\u2026") {
-  if (str.length <= length) return str;
-  return str.slice(0, length - 1) + ellipsis;
-}
-
-// src/concurrentCalls.ts
-function formatErrorMessagesWithCounts(messages, failed, total) {
-  const errorMessageCounts = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    errorMessageCounts.set(message, (errorMessageCounts.get(message) || 0) + 1);
-  }
-  const formattedMessages = Array.from(errorMessageCounts.entries()).map(
-    ([message, count]) => count > 1 ? `${message} (${count}x)` : message
-  );
-  return `${failed}/${total} calls failed:
-${truncateArray(
-    formattedMessages,
-    5,
-    "..."
-  ).join("\n")}`;
-}
-var ConcurrentCallsAggregateError = class extends AggregateError {
-  errors = [];
-  total = 0;
-  failed = 0;
-  constructor(errors, total, failed) {
-    const messages = errors.map(
-      (error) => `- ${truncateString(
-        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
-        100
-      )}`
-    );
-    const message = formatErrorMessagesWithCounts(messages, failed, total);
-    super(errors, message);
-    this.errors = errors;
-    this.total = total;
-    this.failed = failed;
-  }
-};
-var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
-  errors = [];
-  errorsWithMetadata = [];
-  total = 0;
-  failed = 0;
-  constructor(errors, total, failed) {
-    const messages = errors.map(({ error, metadata }) => {
-      let metadataPrefix = typeof metadata === "string" || typeof metadata === "number" || typeof metadata === "boolean" ? `${metadata}: ` : "";
-      try {
-        const isArray = Array.isArray(metadata);
-        if (isObject(metadata) || isArray) {
-          const stringifiedMetadata = JSON.stringify(metadata);
-          if (stringifiedMetadata.length < 30) {
-            metadataPrefix = `${stringifiedMetadata}: `;
-          } else {
-            metadataPrefix = `[${isArray ? "Array" : "Object"} metadata]: `;
-          }
-        }
-      } catch (_) {
-      }
-      return `- ${metadataPrefix}${truncateString(
-        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
-        100
-      )}`;
-    });
-    const message = formatErrorMessagesWithCounts(messages, failed, total);
-    const errorInstances = errors.map((e) => e.error);
-    super(errorInstances, message);
-    this.errors = errorInstances;
-    this.errorsWithMetadata = errors;
-    this.total = total;
-    this.failed = failed;
-  }
-};
-var ConcurrentCalls = class {
-  #pendingCalls = [];
-  #alreadyRun = false;
-  allowResultify = true;
-  constructor(allowResultify) {
-    this.allowResultify = allowResultify;
-  }
-  add(...calls) {
-    this.#pendingCalls.push(...calls);
-    return this;
-  }
-  resultifyAdd(...calls) {
-    if (!this.allowResultify) {
-      throw new Error(
-        "resultifyAdd is not allowed when using concurrentResults"
-      );
-    }
-    const processedCalls = calls.map((call) => {
-      return async () => {
-        try {
-          const valueOrPromise = call();
-          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));
-        }
-      };
-    });
-    return this.add(...processedCalls);
-  }
-  async runAll({ delayStart } = {}) {
-    invariant(!this.#alreadyRun, "Already run");
-    this.#alreadyRun = true;
-    try {
-      const asyncResults = await Promise.all(
-        this.#pendingCalls.map(async (fn, i) => {
-          try {
-            if (delayStart) {
-              await sleep(delayStart(i));
-            }
-            const result = await 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 {
-          if (delayStart) {
-            await sleep(delayStart(i));
-          }
-          const result = await 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 ConcurrentCallsAggregateError(failed, total, failed.length) : null;
-    this.#pendingCalls = [];
-    return {
-      succeeded,
-      failures: failed,
-      allFailed,
-      total,
-      aggregatedError
-    };
-  }
-};
-function concurrentCalls() {
-  return new ConcurrentCalls(true);
-}
-var ConcurrentCallsWithMetadata = class {
-  #pendingCalls = [];
-  #alreadyRun = false;
-  allowResultify = true;
-  constructor(allowResultify) {
-    this.allowResultify = allowResultify;
-  }
-  add(...calls) {
-    invariant(
-      !this.#alreadyRun,
-      "Cannot add calls after execution has started."
-    );
-    this.#pendingCalls.push(...calls);
-    return this;
-  }
-  resultifyAdd(...items) {
-    if (!this.allowResultify) {
-      throw new Error(
-        "resultifyAdd is not allowed when using concurrentResultsWithMetadata"
-      );
-    }
-    const processedItems = items.map(({ fn, metadata }) => {
-      const cb = () => (0, import_t_result.resultify)(async () => {
-        const valueOrPromise = fn();
-        const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
-        return value;
-      });
-      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 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: [],
-        failures: [],
-        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 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 ConcurrentCallsWithMetadataAggregateError(
-      failedProcessing,
-      total,
-      failedProcessing.length
-    ) : null;
-    return {
-      succeeded: succeededProcessing,
-      failed: failedProcessing,
-      failures: failedProcessing,
-      results: resultsProcessing,
-      allFailed,
-      total,
-      aggregatedError
-    };
-  }
-};
-function concurrentCallsWithMetadata() {
-  return new ConcurrentCallsWithMetadata(true);
-}
-function concurrentResultCalls() {
-  return new ConcurrentCalls(false);
-}
-function concurrentResultsWithMetadata() {
-  return new ConcurrentCallsWithMetadata(false);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ConcurrentCallsAggregateError,
-  ConcurrentCallsWithMetadataAggregateError,
-  concurrentCalls,
-  concurrentCallsWithMetadata,
-  concurrentResultCalls,
-  concurrentResultsWithMetadata
-});

package/dist/concurrentCalls.d.cts

@@ -1,116 +0,0 @@
-import { ResultValidErrors, Result } from 't-result';
-
-declare class ConcurrentCallsAggregateError extends AggregateError {
-    errors: ResultValidErrors[];
-    total: number;
-    failed: number;
-    constructor(errors: ResultValidErrors[], total: number, failed: number);
-}
-declare class ConcurrentCallsWithMetadataAggregateError<M extends ValidMetadata> extends AggregateError {
-    errors: ResultValidErrors[];
-    errorsWithMetadata: {
-        error: ResultValidErrors;
-        metadata: M;
-    }[];
-    total: number;
-    failed: number;
-    constructor(errors: {
-        error: ResultValidErrors;
-        metadata: M;
-    }[], total: number, failed: number);
-}
-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 ResultValidErrors = Error> = {
-    metadata: M;
-    error: E;
-};
-type Action<R, E extends ResultValidErrors> = () => Promise<Result<R, E>>;
-type SettledResultWithMetadata<R, M, E extends ResultValidErrors = Error> = {
-    ok: true;
-    value: R;
-    metadata: M;
-    error: false;
-} | {
-    ok: false;
-    error: E;
-    metadata: M;
-};
-declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error> {
-    #private;
-    allowResultify: boolean;
-    constructor(allowResultify: boolean);
-    add(...calls: Action<R, E>[]): this;
-    resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
-    runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
-    runAllSettled({ delayStart }?: RunProps): Promise<{
-        allFailed: boolean;
-        failures: E[];
-        succeeded: R[];
-        total: number;
-        aggregatedError: ConcurrentCallsAggregateError | null;
-    }>;
-}
-/**
- * Executes multiple asynchronous calls concurrently and collects the results in
- * a easier to use format.
- *
- * @template R - The type of the result value.
- */
-declare function concurrentCalls<R = unknown>(): ConcurrentCalls<R, Error>;
-declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends ResultValidErrors = Error> {
-    #private;
-    allowResultify: boolean;
-    constructor(allowResultify: boolean);
-    add(...calls: {
-        fn: Action<R, E>;
-        metadata: M;
-    }[]): this;
-    resultifyAdd(...items: {
-        fn: (() => R) | (() => Promise<R>);
-        metadata: M;
-    }[]): this;
-    runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
-    runAllSettled({ delayStart }?: RunProps): Promise<{
-        allFailed: boolean;
-        /** @deprecated Use failures property instead */
-        failed: FailedCall<M, E>[];
-        failures: FailedCall<M, E>[];
-        succeeded: SucceededCall<R, M>[];
-        total: number;
-        results: SettledResultWithMetadata<R, M, E>[];
-        aggregatedError: ConcurrentCallsWithMetadataAggregateError<M> | null;
-    }>;
-}
-/**
- * Executes multiple asynchronous calls concurrently with metadata for each call
- * 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.
- */
-declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
-type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
-type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
-/**
- * Executes multiple asynchronous result calls concurrently and collects the
- * results in a easier to use format.
- *
- * @template R - The type of the result function that will be called.
- */
-declare function concurrentResultCalls<ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
-/**
- * Executes multiple asynchronous result calls concurrently with metadata for
- * each call and collects the results in a easier to use format.
- *
- * @template ResultFn - The type of the result function that will be called.
- */
-declare function concurrentResultsWithMetadata<M extends ValidMetadata, ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCallsWithMetadata<M, ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
-
-export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata, concurrentResultCalls, concurrentResultsWithMetadata };