obsidian-dev-utils 32.0.0 → 32.0.2-beta.1

package/dist/lib/cjs/Async.cjs

@@ -25,9 +25,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Async_exports = {};
 __export(Async_exports, {
-  INFINITE_TIMEOUT: () => INFINITE_TIMEOUT,
   addErrorHandler: () => addErrorHandler,
   asyncFilter: () => asyncFilter,
+  asyncFilterInPlace: () => asyncFilterInPlace,
   asyncFlatMap: () => asyncFlatMap,
   asyncMap: () => asyncMap,
   convertAsyncToSync: () => convertAsyncToSync,
@@ -36,11 +36,17 @@ __export(Async_exports, {
   invokeAsyncSafely: () => invokeAsyncSafely,
   invokeAsyncSafelyAfterDelay: () => invokeAsyncSafelyAfterDelay,
   marksAsTerminateRetry: () => marksAsTerminateRetry,
+  neverEnds: () => neverEnds,
+  nextTickAsync: () => nextTickAsync,
+  promiseAllAsyncFnsSequentially: () => promiseAllAsyncFnsSequentially,
+  promiseAllSequentially: () => promiseAllSequentially,
+  queueMicrotaskAsync: () => queueMicrotaskAsync,
   requestAnimationFrameAsync: () => requestAnimationFrameAsync,
   retryWithTimeout: () => retryWithTimeout,
   runWithTimeout: () => runWithTimeout,
+  setImmediateAsync: () => setImmediateAsync,
+  setTimeoutAsync: () => setTimeoutAsync,
   sleep: () => sleep,
-  throwOnAbort: () => throwOnAbort,
   timeout: () => timeout,
   toArray: () => toArray
 });
@@ -48,49 +54,126 @@ module.exports = __toCommonJS(Async_exports);
 var import_AbortController = require('./AbortController.cjs');
 var import_Debug = require('./Debug.cjs');
 var import_Error = require('./Error.cjs');
-const INFINITE_TIMEOUT = Number.POSITIVE_INFINITY;
-async function addErrorHandler(asyncFn) {
-  const asyncErrorWrapper = new Error(import_Error.ASYNC_ERROR_WRAPPER_MESSAGE);
+var import_Function = require('./Function.cjs');
+async function addErrorHandler(asyncFn, stackTrace) {
+  stackTrace ??= (0, import_Error.getStackTrace)(1);
   try {
     await asyncFn();
   } catch (asyncError) {
-    asyncErrorWrapper.cause = asyncError;
-    (0, import_Error.emitAsyncErrorEvent)(asyncErrorWrapper);
+    (0, import_Error.emitAsyncErrorEvent)(new import_Error.CustomStackTraceError(import_Error.ASYNC_WRAPPER_ERROR_MESSAGE, stackTrace, asyncError));
   }
 }
 async function asyncFilter(arr, predicate) {
-  const predicateResults = await asyncMap(arr, predicate);
-  return arr.filter((_, index) => predicateResults[index] ?? false);
+  const ans = [];
+  const length = arr.length;
+  for (let i = 0; i < length; i++) {
+    if (!Object.hasOwn(arr, i)) {
+      continue;
+    }
+    const item = arr[i];
+    if (await predicate(item, i, arr)) {
+      ans.push(item);
+    }
+  }
+  return ans;
+}
+async function asyncFilterInPlace(arr, predicate) {
+  const length = arr.length;
+  let writeIndex = 0;
+  for (let readIndex = 0; readIndex < length; readIndex++) {
+    if (!Object.hasOwn(arr, readIndex)) {
+      continue;
+    }
+    const current = arr[readIndex];
+    if (await predicate(current, readIndex, arr)) {
+      arr[writeIndex++] = current;
+    }
+  }
+  arr.length = writeIndex;
 }
 async function asyncFlatMap(arr, callback) {
   return (await asyncMap(arr, callback)).flat();
 }
 async function asyncMap(arr, callback) {
-  return await Promise.all(arr.map(callback));
+  return await promiseAllSequentially(arr.map(callback));
 }
-function convertAsyncToSync(asyncFunc) {
+function convertAsyncToSync(asyncFunc, stackTrace) {
+  stackTrace ??= (0, import_Error.getStackTrace)(1);
   return (...args) => {
-    invokeAsyncSafely(() => asyncFunc(...args));
+    const innerStackTrace = (0, import_Error.getStackTrace)(1);
+    stackTrace = `${stackTrace ?? ""}
+    at --- convertAsyncToSync --- (0)
+${innerStackTrace}`;
+    invokeAsyncSafely(() => asyncFunc(...args), stackTrace);
   };
 }
 function convertSyncToAsync(syncFn) {
-  return (...args) => Promise.resolve().then(() => syncFn(...args));
+  return async (...args) => {
+    await Promise.resolve();
+    return syncFn(...args);
+  };
 }
 async function ignoreError(promise, fallbackValue) {
+  const ignoreErrorDebugger = (0, import_Debug.getLibDebugger)("Async:ignoreError");
+  const stackTrace = (0, import_Error.getStackTrace)(1);
   try {
     return await promise;
-  } catch {
+  } catch (e) {
+    ignoreErrorDebugger("Ignored error", new import_Error.CustomStackTraceError("Ignored error", stackTrace, e));
     return fallbackValue;
   }
 }
-function invokeAsyncSafely(asyncFn) {
-  void addErrorHandler(asyncFn);
+function invokeAsyncSafely(asyncFn, stackTrace) {
+  stackTrace ??= (0, import_Error.getStackTrace)(1);
+  void addErrorHandler(asyncFn, stackTrace);
 }
-function invokeAsyncSafelyAfterDelay(asyncFn, delayInMilliseconds = 0) {
-  window.setTimeout(convertAsyncToSync(async () => await asyncFn()), delayInMilliseconds);
+function invokeAsyncSafelyAfterDelay(asyncFn, delayInMilliseconds = 0, stackTrace, abortSignal) {
+  abortSignal ??= (0, import_AbortController.abortSignalNever)();
+  abortSignal.throwIfAborted();
+  stackTrace ??= (0, import_Error.getStackTrace)(1);
+  invokeAsyncSafely(async () => {
+    await sleep(delayInMilliseconds, abortSignal, true);
+    await asyncFn(abortSignal);
+  }, stackTrace);
+}
+async function promiseAllAsyncFnsSequentially(asyncFns) {
+  const results = [];
+  for (const asyncFn of asyncFns) {
+    results.push(await asyncFn());
+  }
+  return results;
+}
+async function promiseAllSequentially(promises) {
+  return await promiseAllAsyncFnsSequentially(promises.map((promise) => () => promise));
+}
+const terminateRetryErrors = /* @__PURE__ */ new WeakSet();
+class Result {
+  constructor(result) {
+    this.result = result;
+  }
 }
 function marksAsTerminateRetry(error) {
-  return Object.assign(error, { __terminateRetry: true });
+  terminateRetryErrors.add(error);
+}
+async function neverEnds() {
+  await new Promise(() => {
+    (0, import_Function.noop)();
+  });
+  throw new Error("Should never happen");
+}
+async function nextTickAsync() {
+  return new Promise((resolve) => {
+    process.nextTick(() => {
+      resolve();
+    });
+  });
+}
+async function queueMicrotaskAsync() {
+  return new Promise((resolve) => {
+    queueMicrotask(() => {
+      resolve();
+    });
+  });
 }
 async function requestAnimationFrameAsync() {
   return new Promise((resolve) => {
@@ -103,7 +186,7 @@ async function retryWithTimeout(fn, retryOptions, stackTrace) {
   const retryWithTimeoutDebugger = (0, import_Debug.getLibDebugger)("Async:retryWithTimeout");
   stackTrace ??= (0, import_Error.getStackTrace)(1);
   const DEFAULT_RETRY_OPTIONS = {
-    abortSignal: import_AbortController.abortSignalNever,
+    abortSignal: (0, import_AbortController.abortSignalNever)(),
     // eslint-disable-next-line no-magic-numbers
     retryDelayInMilliseconds: 100,
     shouldRetryOnError: false,
@@ -112,107 +195,105 @@ async function retryWithTimeout(fn, retryOptions, stackTrace) {
   };
   const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
   fullOptions.abortSignal.throwIfAborted();
-  await runWithTimeout(fullOptions.timeoutInMilliseconds, async (abortSignal) => {
-    const combinedAbortSignal = (0, import_AbortController.abortSignalAny)([fullOptions.abortSignal, abortSignal]);
-    let attempt = 0;
-    while (true) {
+  await runWithTimeout(
+    fullOptions.timeoutInMilliseconds,
+    async (abortSignal) => {
+      const combinedAbortSignal = (0, import_AbortController.abortSignalAny)([fullOptions.abortSignal, abortSignal]);
       combinedAbortSignal.throwIfAborted();
-      attempt++;
-      let isSuccess;
-      try {
-        isSuccess = await fn(combinedAbortSignal);
-      } catch (error) {
-        if (combinedAbortSignal.aborted || !fullOptions.shouldRetryOnError || error.__terminateRetry) {
-          throw error;
+      let attempt = 0;
+      while (!combinedAbortSignal.aborted) {
+        attempt++;
+        let isSuccess;
+        try {
+          isSuccess = await fn(combinedAbortSignal);
+        } catch (error) {
+          if (combinedAbortSignal.aborted || !fullOptions.shouldRetryOnError || terminateRetryErrors.has(error)) {
+            throw new import_Error.CustomStackTraceError("retryWithTimeout failed", stackTrace, error);
+          }
+          (0, import_Error.printError)(error);
+          isSuccess = false;
         }
-        (0, import_Error.printError)(error);
-        isSuccess = false;
-      }
-      if (isSuccess) {
-        if (attempt > 1) {
-          retryWithTimeoutDebugger(`Retry completed successfully after ${String(attempt)} attempts`);
+        if (isSuccess) {
+          retryWithTimeoutDebugger(`Retry completed successfully after ${String(attempt)} attempts`, {
+            fn
+          });
           retryWithTimeoutDebugger.printStackTrace(stackTrace);
+          return;
         }
-        return;
+        retryWithTimeoutDebugger(
+          `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,
+          {
+            fn
+          }
+        );
+        retryWithTimeoutDebugger.printStackTrace(stackTrace);
+        await sleep(fullOptions.retryDelayInMilliseconds);
       }
-      retryWithTimeoutDebugger(
-        `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,
-        {
-          fn
-        }
-      );
-      retryWithTimeoutDebugger.printStackTrace(stackTrace);
-      await sleep(fullOptions.retryDelayInMilliseconds);
-    }
-  }, { retryFn: fn });
+    },
+    { retryFn: fn },
+    stackTrace
+  );
 }
-async function runWithTimeout(timeoutInMilliseconds, fn, context) {
-  let isTimedOut = true;
-  let result = null;
+async function runWithTimeout(timeoutInMilliseconds, fn, context, stackTrace) {
+  stackTrace ??= (0, import_Error.getStackTrace)(1);
   const startTime = performance.now();
   const abortController = new AbortController();
-  if (timeoutInMilliseconds === INFINITE_TIMEOUT) {
-    await run();
-    return result;
-  }
   await Promise.race([run(), innerTimeout()]);
-  if (isTimedOut) {
-    throw new Error("Timed out");
+  if (abortController.signal.reason instanceof Result) {
+    return abortController.signal.reason.result;
   }
-  return result;
+  throw new import_Error.CustomStackTraceError("Run with timeout failed", stackTrace, abortController.signal.reason);
   async function run() {
     try {
-      result = await fn(abortController.signal);
+      const result = await fn(abortController.signal);
       const duration = performance.now() - startTime;
-      (0, import_Debug.getLibDebugger)("Async:runWithTimeout")(`Execution time: ${String(duration)} milliseconds`, { context, fn });
-    } finally {
-      isTimedOut = false;
+      const runWithTimeoutDebugger = (0, import_Debug.getLibDebugger)("Async:runWithTimeout");
+      runWithTimeoutDebugger(`Execution time: ${String(duration)} milliseconds`, { context, fn });
+      runWithTimeoutDebugger.printStackTrace(stackTrace ?? "");
+      abortController.abort(new Result(result));
+    } catch (e) {
+      abortController.abort(e);
     }
   }
   async function innerTimeout() {
-    if (!isTimedOut) {
-      return;
-    }
-    await sleep(timeoutInMilliseconds);
-    if (!isTimedOut) {
-      return;
-    }
-    const duration = performance.now() - startTime;
-    console.warn(`Timed out in ${String(duration)} milliseconds`, { context, fn });
-    const _debugger = (0, import_Debug.getLibDebugger)("Async:runWithTimeout:timeout");
-    if (_debugger.enabled) {
-      _debugger(
-        `The execution is not terminated because debugger ${_debugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md for more information`
+    while (!abortController.signal.aborted) {
+      await sleep(timeoutInMilliseconds, abortController.signal);
+      if (abortController.signal.aborted) {
+        return;
+      }
+      const duration = performance.now() - startTime;
+      console.warn(`Timed out after ${String(duration)} milliseconds`, { context, fn });
+      const timeoutDebugger = (0, import_Debug.getLibDebugger)("Async:runWithTimeout:timeout");
+      if (!timeoutDebugger.enabled) {
+        abortController.abort(new Error(`Timed out after ${String(duration)} milliseconds`));
+        return;
+      }
+      timeoutDebugger(
+        `The execution is not terminated because debugger ${timeoutDebugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md for more information`
       );
-      await innerTimeout();
     }
-    abortController.abort();
   }
 }
-async function sleep(milliseconds) {
-  await new Promise((resolve) => {
-    window.setTimeout(resolve, milliseconds);
+async function setImmediateAsync() {
+  return new Promise((resolve) => {
+    setImmediate(() => {
+      resolve();
+    });
   });
 }
-function throwOnAbort(abortSignal) {
-  return new Promise((_resolve, reject) => {
-    if (handleAbort()) {
-      return;
-    }
-    abortSignal.addEventListener("abort", handleAbort, { once: true });
-    function handleAbort() {
-      try {
-        abortSignal.throwIfAborted();
-        return false;
-      } catch (e) {
-        reject(e);
-        return true;
-      }
-    }
+async function setTimeoutAsync(delay) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, delay);
   });
 }
-async function timeout(timeoutInMilliseconds) {
-  await sleep(timeoutInMilliseconds);
+async function sleep(milliseconds, abortSignal, shouldThrowOnAbort) {
+  await (0, import_AbortController.waitForAbort)((0, import_AbortController.abortSignalAny)([abortSignal ?? (0, import_AbortController.abortSignalNever)(), (0, import_AbortController.abortSignalTimeout)(milliseconds)]));
+  if (shouldThrowOnAbort) {
+    abortSignal?.throwIfAborted();
+  }
+}
+async function timeout(timeoutInMilliseconds, abortSignal, shouldThrowOnAbort) {
+  await sleep(timeoutInMilliseconds, abortSignal, shouldThrowOnAbort);
   throw new Error(`Timed out in ${String(timeoutInMilliseconds)} milliseconds`);
 }
 async function toArray(iter) {
@@ -224,9 +305,9 @@ async function toArray(iter) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  INFINITE_TIMEOUT,
   addErrorHandler,
   asyncFilter,
+  asyncFilterInPlace,
   asyncFlatMap,
   asyncMap,
   convertAsyncToSync,
@@ -235,12 +316,18 @@ async function toArray(iter) {
   invokeAsyncSafely,
   invokeAsyncSafelyAfterDelay,
   marksAsTerminateRetry,
+  neverEnds,
+  nextTickAsync,
+  promiseAllAsyncFnsSequentially,
+  promiseAllSequentially,
+  queueMicrotaskAsync,
   requestAnimationFrameAsync,
   retryWithTimeout,
   runWithTimeout,
+  setImmediateAsync,
+  setTimeoutAsync,
   sleep,
-  throwOnAbort,
   timeout,
   toArray
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/Async.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for asynchronous operations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport {\n  abortSignalAny,\n  abortSignalNever\n} from './AbortController.ts';\nimport { getLibDebugger } from './Debug.ts';\nimport {\n  ASYNC_ERROR_WRAPPER_MESSAGE,\n  emitAsyncErrorEvent,\n  getStackTrace,\n  printError\n} from './Error.ts';\n\n/**\n * A type representing a function that resolves a {@link Promise}.\n *\n * @typeParam T - The type of the value.\n */\nexport type PromiseResolve<T> = undefined extends T ? (value?: PromiseLike<T> | T) => void\n  : (value: PromiseLike<T> | T) => void;\n\n/**\n * A constant representing an infinite timeout.\n */\nexport const INFINITE_TIMEOUT = Number.POSITIVE_INFINITY;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The abort signal to cancel the retry operation.\n   */\n  abortSignal?: AbortSignal;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   */\n  shouldRetryOnError?: boolean;\n\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds?: number;\n}\n\n/**\n * A marker interface to indicate that an error should terminate retry logic.\n */\nexport interface TerminateRetry {\n  /**\n   * A marker property to indicate that an error should terminate retry logic.\n   */\n  __terminateRetry: true;\n}\n\n/**\n * Adds an error handler to a {@link Promise} that catches any errors and emits an async error event.\n *\n * @param asyncFn - The asynchronous function to add an error handler to.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void> {\n  const asyncErrorWrapper = new Error(ASYNC_ERROR_WRAPPER_MESSAGE);\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    asyncErrorWrapper.cause = asyncError;\n    emitAsyncErrorEvent(asyncErrorWrapper);\n  }\n}\n\n/**\n * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param arr - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A {@link Promise} that resolves with an array of elements that satisfy the predicate function.\n */\nexport async function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index] ?? false);\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over and flatten.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with a flattened array of the results of the callback function.\n */\nexport async function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).flat();\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with an array of the results of the callback function.\n */\nexport async function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]> {\n  return await Promise.all(arr.map(callback));\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @param asyncFunc - The asynchronous function to convert.\n * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (...args: Args) => Promise<unknown>): (...args: Args) => void {\n  return (...args: Args): void => {\n    invokeAsyncSafely(() => asyncFunc(...args));\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a {@link Promise}.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFn - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Args extends unknown[], Result>(syncFn: (...args: Args) => Result): (...args: Args) => Promise<Result> {\n  return (...args: Args): Promise<Result> => Promise.resolve().then(() => syncFn(...args));\n}\n\n/**\n * Ignores an error that is thrown by an asynchronous function.\n *\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - Always `undefined`.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or fails.\n */\nexport async function ignoreError(promise: Promise<unknown>, fallbackValue?: undefined): Promise<void>;\n\n/**\n * Invokes an asynchronous function and returns a fallback value if an error is thrown.\n *\n * @typeParam T - The type of the value returned by the asynchronous function.\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - The value to return if an error is thrown.\n * @returns A {@link Promise} that resolves with the value returned by the asynchronous function or the fallback value if an error is thrown.\n */\nexport async function ignoreError<T>(promise: Promise<T>, fallbackValue: T): Promise<T> {\n  try {\n    return await promise;\n  } catch {\n    return fallbackValue;\n  }\n}\n\n/**\n * Invokes a {@link Promise} and safely handles any errors by catching them and emitting an async error event.\n *\n * @param asyncFn - The asynchronous function to invoke safely.\n */\nexport function invokeAsyncSafely(asyncFn: () => Promise<unknown>): void {\n  // eslint-disable-next-line no-void\n  void addErrorHandler(asyncFn);\n}\n\n/**\n * Invokes an asynchronous function after a delay.\n *\n * @param asyncFn - The asynchronous function to invoke.\n * @param delayInMilliseconds - The delay in milliseconds.\n */\nexport function invokeAsyncSafelyAfterDelay(asyncFn: () => Promisable<unknown>, delayInMilliseconds = 0): void {\n  window.setTimeout(convertAsyncToSync(async () => await asyncFn()), delayInMilliseconds);\n}\n\n/**\n * Marks an error to terminate retry logic.\n *\n * @param error - The error to mark to terminate retry logic.\n * @returns An error that should terminate retry logic.\n */\nexport function marksAsTerminateRetry<TError extends Error>(error: TError): TerminateRetry & TError {\n  return Object.assign(error, { __terminateRetry: true }) as TerminateRetry & TError;\n}\n\n/**\n * Gets the next request animation frame.\n *\n * @returns A promise that resolves when the next request animation frame is available.\n */\nexport async function requestAnimationFrameAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    requestAnimationFrame(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Retries the provided function until it returns true or the timeout is reached.\n *\n * @param fn - The function to retry.\n * @param retryOptions - Optional parameters to configure the retry behavior.\n * @param stackTrace - Optional stack trace.\n * @returns A {@link Promise} that resolves when the function returns true or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(fn: (abortSignal: AbortSignal) => Promisable<boolean>, retryOptions?: RetryOptions, stackTrace?: string): Promise<void> {\n  const retryWithTimeoutDebugger = getLibDebugger('Async:retryWithTimeout');\n  stackTrace ??= getStackTrace(1);\n  const DEFAULT_RETRY_OPTIONS = {\n    abortSignal: abortSignalNever,\n    // eslint-disable-next-line no-magic-numbers\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: false,\n    // eslint-disable-next-line no-magic-numbers\n    timeoutInMilliseconds: 5000\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  fullOptions.abortSignal.throwIfAborted();\n\n  await runWithTimeout(fullOptions.timeoutInMilliseconds, async (abortSignal: AbortSignal) => {\n    const combinedAbortSignal = abortSignalAny([fullOptions.abortSignal, abortSignal]);\n    let attempt = 0;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    while (true) {\n      combinedAbortSignal.throwIfAborted();\n      attempt++;\n      let isSuccess: boolean;\n      try {\n        isSuccess = await fn(combinedAbortSignal);\n      } catch (error) {\n        if (combinedAbortSignal.aborted || !fullOptions.shouldRetryOnError || (error as Partial<TerminateRetry>).__terminateRetry) {\n          throw error;\n        }\n        printError(error);\n        isSuccess = false;\n      }\n      if (isSuccess) {\n        if (attempt > 1) {\n          retryWithTimeoutDebugger(`Retry completed successfully after ${String(attempt)} attempts`);\n          retryWithTimeoutDebugger.printStackTrace(stackTrace);\n        }\n        return;\n      }\n\n      retryWithTimeoutDebugger(\n        `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,\n        {\n          fn\n        }\n      );\n      retryWithTimeoutDebugger.printStackTrace(stackTrace);\n      await sleep(fullOptions.retryDelayInMilliseconds);\n    }\n  }, { retryFn: fn });\n}\n\n/**\n * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.\n *\n * If `DEBUG=obsidian-dev-utils:Async:runWithTimeout` is set, the execution is not terminated after the timeout and the function is allowed to run indefinitely.\n *\n * @typeParam R - The type of the result from the asynchronous function.\n * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.\n * @param fn - The function to execute.\n * @param context - The context of the function.\n * @returns A {@link Promise} that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<R>(timeoutInMilliseconds: number, fn: (abortSignal: AbortSignal) => Promisable<R>, context?: unknown): Promise<R> {\n  let isTimedOut = true;\n  let result: R = null as R;\n  const startTime = performance.now();\n\n  const abortController = new AbortController();\n\n  if (timeoutInMilliseconds === INFINITE_TIMEOUT) {\n    await run();\n    return result;\n  }\n\n  await Promise.race([run(), innerTimeout()]);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (isTimedOut) {\n    throw new Error('Timed out');\n  }\n  return result;\n\n  async function run(): Promise<void> {\n    try {\n      result = await fn(abortController.signal);\n      const duration = performance.now() - startTime;\n      getLibDebugger('Async:runWithTimeout')(`Execution time: ${String(duration)} milliseconds`, { context, fn });\n    } finally {\n      isTimedOut = false;\n    }\n  }\n\n  async function innerTimeout(): Promise<void> {\n    if (!isTimedOut) {\n      return;\n    }\n    await sleep(timeoutInMilliseconds);\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (!isTimedOut) {\n      return;\n    }\n    const duration = performance.now() - startTime;\n    console.warn(`Timed out in ${String(duration)} milliseconds`, { context, fn });\n    const _debugger = getLibDebugger('Async:runWithTimeout:timeout');\n    if (_debugger.enabled) {\n      _debugger(\n        `The execution is not terminated because debugger ${_debugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md for more information`\n      );\n      await innerTimeout();\n    }\n    abortController.abort();\n  }\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param milliseconds - The time to wait in milliseconds.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => {\n    window.setTimeout(resolve, milliseconds);\n  });\n}\n\n/**\n * Returns a {@link Promise} that rejects when the abort signal is aborted.\n *\n * @param abortSignal - The abort signal to listen to.\n * @returns A {@link Promise} that rejects when the abort signal is aborted.\n */\nexport function throwOnAbort(abortSignal: AbortSignal): Promise<void> {\n  return new Promise((_resolve, reject) => {\n    if (handleAbort()) {\n      return;\n    }\n    abortSignal.addEventListener('abort', handleAbort, { once: true });\n\n    function handleAbort(): boolean {\n      try {\n        abortSignal.throwIfAborted();\n        return false;\n      } catch (e) {\n        reject(e as Error);\n        return true;\n      }\n    }\n  });\n}\n\n/**\n * Returns a {@link Promise} that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A {@link Promise} that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number): Promise<never> {\n  await sleep(timeoutInMilliseconds);\n  throw new Error(`Timed out in ${String(timeoutInMilliseconds)} milliseconds`);\n}\n\n/**\n * Converts an AsyncIterableIterator to an array by consuming all its elements.\n *\n * @typeParam T - The type of elements produced by the AsyncIterableIterator.\n * @param iter - The AsyncIterableIterator to convert.\n * @returns A {@link Promise} that resolves with an array of all the elements in the AsyncIterableIterator.\n */\nexport async function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]> {\n  const arr: T[] = [];\n  for await (const item of iter) {\n    arr.push(item);\n  }\n  return arr;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/Async.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for asynchronous operations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport {\n  abortSignalAny,\n  abortSignalNever,\n  abortSignalTimeout,\n  waitForAbort\n} from './AbortController.ts';\nimport { getLibDebugger } from './Debug.ts';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace,\n  printError\n} from './Error.ts';\nimport { noop } from './Function.ts';\n\n/**\n * A type representing a function that resolves a {@link Promise}.\n *\n * @typeParam T - The type of the value.\n */\nexport type PromiseResolve<T> = undefined extends T ? (value?: PromiseLike<T> | T) => void\n  : (value: PromiseLike<T> | T) => void;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The abort signal to cancel the retry operation.\n   */\n  abortSignal?: AbortSignal;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   */\n  shouldRetryOnError?: boolean;\n\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds?: number;\n}\n\n/**\n * Adds an error handler to a {@link Promise} that catches any errors and emits an async error event.\n *\n * @param asyncFn - The asynchronous function to add an error handler to.\n * @param stackTrace - The stack trace of the source function.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFn: () => Promise<unknown>, stackTrace?: string): Promise<void> {\n  stackTrace ??= getStackTrace(1);\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    emitAsyncErrorEvent(new CustomStackTraceError(ASYNC_WRAPPER_ERROR_MESSAGE, stackTrace, asyncError));\n  }\n}\n\n/**\n * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param arr - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A {@link Promise} that resolves with an array of elements that satisfy the predicate function.\n */\nexport async function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]> {\n  const ans: T[] = [];\n\n  const length = arr.length;\n  for (let i = 0; i < length; i++) {\n    if (!Object.hasOwn(arr, i)) {\n      continue;\n    }\n\n    const item = arr[i] as T;\n    if (await predicate(item, i, arr)) {\n      ans.push(item);\n    }\n  }\n\n  return ans;\n}\n\n/**\n * Filters an array asynchronously in place, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param arr - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A {@link Promise} that resolves when the array is filtered.\n */\nexport async function asyncFilterInPlace<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<void> {\n  const length = arr.length;\n  let writeIndex = 0;\n  for (let readIndex = 0; readIndex < length; readIndex++) {\n    if (!Object.hasOwn(arr, readIndex)) {\n      continue;\n    }\n\n    const current = arr[readIndex] as T;\n    if (await predicate(current, readIndex, arr)) {\n      // eslint-disable-next-line require-atomic-updates\n      arr[writeIndex++] = current;\n    }\n  }\n  arr.length = writeIndex;\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over and flatten.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with a flattened array of the results of the callback function.\n */\nexport async function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).flat();\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param arr - The array to map over.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with an array of the results of the callback function.\n */\nexport async function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]> {\n  return await promiseAllSequentially(arr.map(callback));\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @param asyncFunc - The asynchronous function to convert.\n * @param stackTrace - The stack trace of the source function.\n * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (...args: Args) => Promise<unknown>, stackTrace?: string): (...args: Args) => void {\n  stackTrace ??= getStackTrace(1);\n  return (...args: Args): void => {\n    const innerStackTrace = getStackTrace(1);\n    stackTrace = `${stackTrace ?? ''}\\n    at --- convertAsyncToSync --- (0)\\n${innerStackTrace}`;\n    invokeAsyncSafely(() => asyncFunc(...args), stackTrace);\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a {@link Promise}.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFn - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Args extends unknown[], Result>(syncFn: (...args: Args) => Result): (...args: Args) => Promise<Result> {\n  return async (...args: Args): Promise<Result> => {\n    await Promise.resolve();\n    return syncFn(...args);\n  };\n}\n\n/**\n * Ignores an error that is thrown by an asynchronous function.\n *\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - Always `undefined`.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or fails.\n */\nexport async function ignoreError(promise: Promise<unknown>, fallbackValue?: undefined): Promise<void>;\n\n/**\n * Invokes an asynchronous function and returns a fallback value if an error is thrown.\n *\n * @typeParam T - The type of the value returned by the asynchronous function.\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - The value to return if an error is thrown.\n * @returns A {@link Promise} that resolves with the value returned by the asynchronous function or the fallback value if an error is thrown.\n */\nexport async function ignoreError<T>(promise: Promise<T>, fallbackValue: T): Promise<T> {\n  const ignoreErrorDebugger = getLibDebugger('Async:ignoreError');\n  const stackTrace = getStackTrace(1);\n  try {\n    return await promise;\n  } catch (e) {\n    ignoreErrorDebugger('Ignored error', new CustomStackTraceError('Ignored error', stackTrace, e));\n    return fallbackValue;\n  }\n}\n\n/**\n * Invokes a {@link Promise} and safely handles any errors by catching them and emitting an async error event.\n *\n * @param asyncFn - The asynchronous function to invoke safely.\n * @param stackTrace - The stack trace of the source function.\n */\nexport function invokeAsyncSafely(asyncFn: () => Promise<unknown>, stackTrace?: string): void {\n  stackTrace ??= getStackTrace(1);\n  // eslint-disable-next-line no-void\n  void addErrorHandler(asyncFn, stackTrace);\n}\n\n/**\n * Invokes an asynchronous function after a delay.\n *\n * @param asyncFn - The asynchronous function to invoke.\n * @param delayInMilliseconds - The delay in milliseconds.\n * @param stackTrace - The stack trace of the source function.\n * @param abortSignal - The abort signal to listen to.\n */\nexport function invokeAsyncSafelyAfterDelay(\n  asyncFn: (abortSignal: AbortSignal) => Promisable<void>,\n  delayInMilliseconds = 0,\n  stackTrace?: string,\n  abortSignal?: AbortSignal\n): void {\n  abortSignal ??= abortSignalNever();\n  abortSignal.throwIfAborted();\n  stackTrace ??= getStackTrace(1);\n  invokeAsyncSafely(async () => {\n    await sleep(delayInMilliseconds, abortSignal, true);\n    await asyncFn(abortSignal);\n  }, stackTrace);\n}\n\n/**\n * Executes async functions sequentially.\n *\n * @typeParam T - The type of the value.\n * @param asyncFns - The async functions to execute sequentially.\n * @returns A {@link Promise} that resolves with an array of the results of the async functions.\n */\nexport async function promiseAllAsyncFnsSequentially<T>(asyncFns: (() => Promisable<T>)[]): Promise<T[]> {\n  const results: T[] = [];\n  for (const asyncFn of asyncFns) {\n    results.push(await asyncFn());\n  }\n  return results;\n}\n\n/**\n * Executes promises sequentially.\n *\n * @typeParam T - The type of the value.\n * @param promises - The promises to execute sequentially.\n * @returns A {@link Promise} that resolves with an array of the results of the promises.\n */\nexport async function promiseAllSequentially<T>(promises: Promisable<T>[]): Promise<T[]> {\n  return await promiseAllAsyncFnsSequentially(promises.map((promise) => () => promise));\n}\n\nconst terminateRetryErrors = new WeakSet<Error>();\n\nclass Result<R> {\n  public constructor(public readonly result: R) {}\n}\n\n/**\n * Marks an error to terminate retry logic.\n *\n * @param error - The error to mark to terminate retry logic.\n */\nexport function marksAsTerminateRetry(error: Error): void {\n  terminateRetryErrors.add(error);\n}\n\n/**\n * An async function that never ends.\n *\n * @returns A {@link Promise} that never resolves.\n */\nexport async function neverEnds(): Promise<never> {\n  await new Promise(() => {\n    noop();\n  });\n  throw new Error('Should never happen');\n}\n\n/**\n * Gets the next tick.\n *\n * @returns A promise that resolves when the next tick is available.\n */\nexport async function nextTickAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    process.nextTick(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Gets the next queue microtask.\n *\n * @returns A promise that resolves when the next queue microtask is available.\n */\nexport async function queueMicrotaskAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    queueMicrotask(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Gets the next request animation frame.\n *\n * @returns A promise that resolves when the next request animation frame is available.\n */\nexport async function requestAnimationFrameAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    requestAnimationFrame(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Retries the provided function until it returns true or the timeout is reached.\n *\n * @param fn - The function to retry.\n * @param retryOptions - Optional parameters to configure the retry behavior.\n * @param stackTrace - Optional stack trace.\n * @returns A {@link Promise} that resolves when the function returns true or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(fn: (abortSignal: AbortSignal) => Promisable<boolean>, retryOptions?: RetryOptions, stackTrace?: string): Promise<void> {\n  const retryWithTimeoutDebugger = getLibDebugger('Async:retryWithTimeout');\n  stackTrace ??= getStackTrace(1);\n  const DEFAULT_RETRY_OPTIONS = {\n    abortSignal: abortSignalNever(),\n    // eslint-disable-next-line no-magic-numbers\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: false,\n    // eslint-disable-next-line no-magic-numbers\n    timeoutInMilliseconds: 5000\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  fullOptions.abortSignal.throwIfAborted();\n\n  await runWithTimeout(\n    fullOptions.timeoutInMilliseconds,\n    async (abortSignal: AbortSignal) => {\n      const combinedAbortSignal = abortSignalAny([fullOptions.abortSignal, abortSignal]);\n      combinedAbortSignal.throwIfAborted();\n      let attempt = 0;\n      while (!combinedAbortSignal.aborted) {\n        attempt++;\n        let isSuccess: boolean;\n        try {\n          isSuccess = await fn(combinedAbortSignal);\n        } catch (error) {\n          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n          if (combinedAbortSignal.aborted || !fullOptions.shouldRetryOnError || terminateRetryErrors.has(error as Error)) {\n            throw new CustomStackTraceError('retryWithTimeout failed', stackTrace, error);\n          }\n          printError(error);\n          isSuccess = false;\n        }\n        if (isSuccess) {\n          retryWithTimeoutDebugger(`Retry completed successfully after ${String(attempt)} attempts`, {\n            fn\n          });\n          retryWithTimeoutDebugger.printStackTrace(stackTrace);\n          return;\n        }\n\n        retryWithTimeoutDebugger(\n          `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,\n          {\n            fn\n          }\n        );\n        retryWithTimeoutDebugger.printStackTrace(stackTrace);\n        await sleep(fullOptions.retryDelayInMilliseconds);\n      }\n    },\n    { retryFn: fn },\n    stackTrace\n  );\n}\n\n/**\n * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.\n *\n * If `DEBUG=obsidian-dev-utils:Async:runWithTimeout` is set, the execution is not terminated after the timeout and the function is allowed to run indefinitely.\n *\n * @typeParam R - The type of the result from the asynchronous function.\n * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.\n * @param fn - The function to execute.\n * @param context - The context of the function.\n * @param stackTrace - The stack trace of the source function.\n * @returns A {@link Promise} that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<R>(\n  timeoutInMilliseconds: number,\n  fn: (abortSignal: AbortSignal) => Promisable<R>,\n  context?: unknown,\n  stackTrace?: string\n): Promise<R> {\n  stackTrace ??= getStackTrace(1);\n  const startTime = performance.now();\n\n  const abortController = new AbortController();\n\n  await Promise.race([run(), innerTimeout()]);\n  if (abortController.signal.reason instanceof Result) {\n    return abortController.signal.reason.result as R;\n  }\n\n  throw new CustomStackTraceError('Run with timeout failed', stackTrace, abortController.signal.reason as unknown);\n\n  async function run(): Promise<void> {\n    try {\n      const result = await fn(abortController.signal);\n      const duration = performance.now() - startTime;\n      const runWithTimeoutDebugger = getLibDebugger('Async:runWithTimeout');\n      runWithTimeoutDebugger(`Execution time: ${String(duration)} milliseconds`, { context, fn });\n      runWithTimeoutDebugger.printStackTrace(stackTrace ?? '');\n      abortController.abort(new Result(result));\n    } catch (e) {\n      abortController.abort(e);\n    }\n  }\n\n  async function innerTimeout(): Promise<void> {\n    while (!abortController.signal.aborted) {\n      await sleep(timeoutInMilliseconds, abortController.signal);\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (abortController.signal.aborted) {\n        return;\n      }\n      const duration = performance.now() - startTime;\n      console.warn(`Timed out after ${String(duration)} milliseconds`, { context, fn });\n      const timeoutDebugger = getLibDebugger('Async:runWithTimeout:timeout');\n      if (!timeoutDebugger.enabled) {\n        abortController.abort(new Error(`Timed out after ${String(duration)} milliseconds`));\n        return;\n      }\n\n      timeoutDebugger(\n        `The execution is not terminated because debugger ${timeoutDebugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md for more information`\n      );\n    }\n  }\n}\n\n/**\n * Gets the next set immediate.\n *\n * @returns A promise that resolves when the next set immediate is available.\n */\nexport async function setImmediateAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    setImmediate(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param delay - The time to wait in milliseconds.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function setTimeoutAsync(delay?: number): Promise<void> {\n  await new Promise((resolve) => {\n    setTimeout(resolve, delay);\n  });\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param milliseconds - The time to wait in milliseconds.\n * @param abortSignal - The abort signal to listen to.\n * @param shouldThrowOnAbort - Whether to throw an error if the abort signal is aborted.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number, abortSignal?: AbortSignal, shouldThrowOnAbort?: boolean): Promise<void> {\n  await waitForAbort(abortSignalAny([abortSignal ?? abortSignalNever(), abortSignalTimeout(milliseconds)]));\n  if (shouldThrowOnAbort) {\n    abortSignal?.throwIfAborted();\n  }\n}\n\n/**\n * Returns a {@link Promise} that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @param abortSignal - The abort signal to listen to.\n * @param shouldThrowOnAbort - Whether to throw an error if the abort signal is aborted.\n * @returns A {@link Promise} that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number, abortSignal?: AbortSignal, shouldThrowOnAbort?: boolean): Promise<never> {\n  await sleep(timeoutInMilliseconds, abortSignal, shouldThrowOnAbort);\n  throw new Error(`Timed out in ${String(timeoutInMilliseconds)} milliseconds`);\n}\n\n/**\n * Converts an AsyncIterableIterator to an array by consuming all its elements.\n *\n * @typeParam T - The type of elements produced by the AsyncIterableIterator.\n * @param iter - The AsyncIterableIterator to convert.\n * @returns A {@link Promise} that resolves with an array of all the elements in the AsyncIterableIterator.\n */\nexport async function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]> {\n  const arr: T[] = [];\n  for await (const item of iter) {\n    arr.push(item);\n  }\n  return arr;\n}\n"],
  "mappings": "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",
  "names": []
}
