obsidian-dev-utils 4.10.0 → 4.12.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # CHANGELOG
 
+## 4.12.0
+
+- Don't allow default exports
+
+## 4.11.0
+
+- Lint
+- Update libs
+- Refactor to Queue
+- Log timeout
+
 ## 4.10.0
 
 - ChainedPromise

package/dist/lib/@types/compare-versions.d.ts

@@ -32,5 +32,6 @@ declare module 'compare-versions' {
     CompareOperator: CompareOperator;
   };
 
+  // eslint-disable-next-line import-x/no-default-export
   export default compareVersions;
 }

package/dist/lib/Async.cjs

@@ -41,6 +41,37 @@ __export(Async_exports, {
 });
 module.exports = __toCommonJS(Async_exports);
 var import_Error = require('./Error.cjs');
+async function addErrorHandler(asyncFn) {
+  try {
+    await asyncFn();
+  } catch (asyncError) {
+    (0, import_Error.emitAsyncErrorEvent)(asyncError);
+  }
+}
+async function asyncFilter(arr, predicate) {
+  const predicateResults = await asyncMap(arr, predicate);
+  return arr.filter((_, index) => predicateResults[index]);
+}
+async function asyncFlatMap(arr, callback) {
+  return (await asyncMap(arr, callback)).flat();
+}
+async function asyncMap(arr, callback) {
+  return await Promise.all(arr.map(callback));
+}
+function convertAsyncToSync(asyncFunc) {
+  return (...args) => {
+    invokeAsyncSafely(() => asyncFunc(...args));
+  };
+}
+function convertSyncToAsync(syncFn) {
+  return (...args) => Promise.resolve().then(() => syncFn(...args));
+}
+function invokeAsyncSafely(asyncFn) {
+  void addErrorHandler(asyncFn);
+}
+function marksAsTerminateRetry(error) {
+  return Object.assign(error, { __terminateRetry: true });
+}
 async function retryWithTimeout(fn, retryOptions = {}) {
   const stackTrace = (0, import_Error.getStackTrace)();
   const DEFAULT_RETRY_OPTIONS = {
@@ -77,44 +108,31 @@ async function retryWithTimeout(fn, retryOptions = {}) {
     }
   });
 }
+async function runWithTimeout(timeoutInMilliseconds, fn) {
+  let timedOut = false;
+  let result = null;
+  await Promise.race([run(), timeout2()]);
+  if (timedOut) {
+    console.error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`, { fn });
+    throw new Error("Timed out");
+  }
+  return result;
+  async function run() {
+    result = await fn();
+    timedOut = false;
+  }
+  async function timeout2() {
+    await sleep(timeoutInMilliseconds);
+    timedOut = true;
+  }
+}
 async function sleep(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-async function runWithTimeout(timeoutInMilliseconds, fn) {
-  return await Promise.race([fn(), timeout(timeoutInMilliseconds)]);
-}
 async function timeout(timeoutInMilliseconds) {
   await sleep(timeoutInMilliseconds);
   throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`);
 }
-function invokeAsyncSafely(asyncFn) {
-  void addErrorHandler(asyncFn);
-}
-async function addErrorHandler(asyncFn) {
-  try {
-    await asyncFn();
-  } catch (asyncError) {
-    (0, import_Error.emitAsyncErrorEvent)(asyncError);
-  }
-}
-function convertAsyncToSync(asyncFunc) {
-  return (...args) => {
-    invokeAsyncSafely(() => asyncFunc(...args));
-  };
-}
-function convertSyncToAsync(syncFn) {
-  return (...args) => Promise.resolve().then(() => syncFn(...args));
-}
-async function asyncMap(arr, callback) {
-  return await Promise.all(arr.map(callback));
-}
-async function asyncFilter(arr, predicate) {
-  const predicateResults = await asyncMap(arr, predicate);
-  return arr.filter((_, index) => predicateResults[index]);
-}
-async function asyncFlatMap(arr, callback) {
-  return (await asyncMap(arr, callback)).flat();
-}
 async function toArray(iter) {
   const arr = [];
   for await (const item of iter) {
@@ -122,9 +140,6 @@ async function toArray(iter) {
   }
   return arr;
 }
-function marksAsTerminateRetry(error) {
-  return Object.assign(error, { __terminateRetry: true });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addErrorHandler,
@@ -141,4 +156,4 @@ function marksAsTerminateRetry(error) {
   timeout,
   toArray
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Async.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Async\n * Contains utility functions for asynchronous operations.\n */\n\nimport {\n  emitAsyncErrorEvent,\n  getStackTrace,\n  printError\n} from './Error.ts';\n\n/**\n * A type representing a value that can either be a direct value or a Promise resolving to that value.\n * @typeParam T - The type of the value.\n */\nexport type MaybePromise<T> = Promise<T> | T;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\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 * 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 * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions: Partial<RetryOptions> = {}): Promise<void> {\n  const stackTrace = getStackTrace();\n  const DEFAULT_RETRY_OPTIONS: RetryOptions = {\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: true,\n    timeoutInMilliseconds: 5000\n  };\n  const overriddenOptions: RetryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(overriddenOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      attempt++;\n      let isSuccess: boolean;\n      try {\n        isSuccess = await fn();\n      } catch (error) {\n        if (!overriddenOptions.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          console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);\n        }\n        return;\n      }\n\n      console.debug(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${overriddenOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        fn,\n        stackTrace\n      });\n      await sleep(overriddenOptions.retryDelayInMilliseconds);\n    }\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 Promise that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => setTimeout(resolve, milliseconds));\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 * @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 * @returns A 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: () => MaybePromise<R>): Promise<R> {\n  return await Promise.race([fn(), timeout(timeoutInMilliseconds)]);\n}\n\n/**\n * Returns a Promise that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A 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 ${timeoutInMilliseconds.toString()} milliseconds`);\n}\n\n/**\n * Invokes a 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  void addErrorHandler(asyncFn);\n}\n\n/**\n * Adds an error handler to a 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 Promise that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void> {\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    emitAsyncErrorEvent(asyncError);\n  }\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 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 * 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 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[]) => MaybePromise<U>): Promise<U[]> {\n  return await Promise.all(arr.map(callback));\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 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[]) => MaybePromise<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index]);\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 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[]) => MaybePromise<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).flat();\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 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\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 * 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);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAIO;AAmCP,eAAsB,iBAAiB,IAAiC,eAAsC,CAAC,GAAkB;AAC/H,QAAM,iBAAa,4BAAc;AACjC,QAAM,wBAAsC;AAAA,IAC1C,0BAA0B;AAAA,IAC1B,oBAAoB;AAAA,IACpB,uBAAuB;AAAA,EACzB;AACA,QAAM,oBAAkC,EAAE,GAAG,uBAAuB,GAAG,aAAa;AACpF,QAAM,eAAe,kBAAkB,uBAAuB,YAAY;AACxE,QAAI,UAAU;AACd,eAAU;AACR;AACA,UAAI;AACJ,UAAI;AACF,oBAAY,MAAM,GAAG;AAAA,MACvB,SAAS,OAAO;AACd,YAAI,CAAC,kBAAkB,sBAAuB,MAAkC,kBAAkB;AAChG,gBAAM;AAAA,QACR;AACA,qCAAW,KAAK;AAChB,oBAAY;AAAA,MACd;AACA,UAAI,WAAW;AACb,YAAI,UAAU,GAAG;AACf,kBAAQ,MAAM,sCAAsC,QAAQ,SAAS,CAAC,WAAW;AAAA,QACnF;AACA;AAAA,MACF;AAEA,cAAQ,MAAM,iBAAiB,QAAQ,SAAS,CAAC,8CAA8C,kBAAkB,yBAAyB,SAAS,CAAC,iBAAiB;AAAA,QACnK;AAAA,QACA;AAAA,MACF,CAAC;AACD,YAAM,MAAM,kBAAkB,wBAAwB;AAAA,IACxD;AAAA,EACF,CAAC;AACH;AAQA,eAAsB,MAAM,cAAqC;AAC/D,QAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,YAAY,CAAC;AAClE;AAUA,eAAsB,eAAkB,uBAA+B,IAAuC;AAC5G,SAAO,MAAM,QAAQ,KAAK,CAAC,GAAG,GAAG,QAAQ,qBAAqB,CAAC,CAAC;AAClE;AAQA,eAAsB,QAAQ,uBAA+C;AAC3E,QAAM,MAAM,qBAAqB;AACjC,QAAM,IAAI,MAAM,gBAAgB,sBAAsB,SAAS,CAAC,eAAe;AACjF;AAOO,SAAS,kBAAkB,SAAuC;AACvE,OAAK,gBAAgB,OAAO;AAC9B;AAQA,eAAsB,gBAAgB,SAAgD;AACpF,MAAI;AACF,UAAM,QAAQ;AAAA,EAChB,SAAS,YAAY;AACnB,0CAAoB,UAAU;AAAA,EAChC;AACF;AASO,SAAS,mBAA2C,WAAyE;AAClI,SAAO,IAAI,SAAqB;AAC9B,sBAAkB,MAAM,UAAU,GAAG,IAAI,CAAC;AAAA,EAC5C;AACF;AAUO,SAAS,mBAAmD,QAAuE;AACxI,SAAO,IAAI,SAAgC,QAAQ,QAAQ,EAAE,KAAK,MAAM,OAAO,GAAG,IAAI,CAAC;AACzF;AAWA,eAAsB,SAAe,KAAU,UAAkF;AAC/H,SAAO,MAAM,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC;AAC5C;AAUA,eAAsB,YAAe,KAAU,WAAyF;AACtI,QAAM,mBAAmB,MAAM,SAAS,KAAK,SAAS;AACtD,SAAO,IAAI,OAAO,CAAC,GAAG,UAAU,iBAAiB,KAAK,CAAC;AACzD;AAWA,eAAsB,aAAmB,KAAU,UAAoF;AACrI,UAAQ,MAAM,SAAS,KAAK,QAAQ,GAAG,KAAK;AAC9C;AASA,eAAsB,QAAW,MAA8C;AAC7E,QAAM,MAAW,CAAC;AAClB,mBAAiB,QAAQ,MAAM;AAC7B,QAAI,KAAK,IAAI;AAAA,EACf;AACA,SAAO;AACT;AAkBO,SAAS,sBAA4C,OAAwC;AAClG,SAAO,OAAO,OAAO,OAAO,EAAE,kBAAkB,KAAK,CAAmB;AAC1E;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Async.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Async\n * Contains utility functions for asynchronous operations.\n */\n\nimport {\n  emitAsyncErrorEvent,\n  getStackTrace,\n  printError\n} from './Error.ts';\n\n/**\n * A type representing a value that can either be a direct value or a Promise resolving to that value.\n * @typeParam T - The type of the value.\n */\nexport type MaybePromise<T> = Promise<T> | T;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\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 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 Promise that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void> {\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    emitAsyncErrorEvent(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 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[]) => MaybePromise<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index]);\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 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[]) => MaybePromise<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 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[]) => MaybePromise<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 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 * Invokes a 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  void addErrorHandler(asyncFn);\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);\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 * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions: Partial<RetryOptions> = {}): Promise<void> {\n  const stackTrace = getStackTrace();\n  const DEFAULT_RETRY_OPTIONS: RetryOptions = {\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: true,\n    timeoutInMilliseconds: 5000\n  };\n  const overriddenOptions: RetryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(overriddenOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      attempt++;\n      let isSuccess: boolean;\n      try {\n        isSuccess = await fn();\n      } catch (error) {\n        if (!overriddenOptions.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          console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);\n        }\n        return;\n      }\n\n      console.debug(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${overriddenOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        fn,\n        stackTrace\n      });\n      await sleep(overriddenOptions.retryDelayInMilliseconds);\n    }\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 * @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 * @returns A 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: () => MaybePromise<R>): Promise<R> {\n  let timedOut = false;\n  let result: R = null as R;\n\n  await Promise.race([run(), timeout()]);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (timedOut) {\n    console.error(`Timed out in ${timeoutInMilliseconds.toString()} milliseconds`, { fn });\n    throw new Error('Timed out');\n  }\n  return result;\n\n  async function run(): Promise<void> {\n    result = await fn();\n    timedOut = false;\n  }\n\n  async function timeout(): Promise<void> {\n    await sleep(timeoutInMilliseconds);\n    timedOut = true;\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 Promise that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => setTimeout(resolve, milliseconds));\n}\n\n/**\n * Returns a Promise that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A 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 ${timeoutInMilliseconds.toString()} 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 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": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAIO;AA4CP,eAAsB,gBAAgB,SAAgD;AACpF,MAAI;AACF,UAAM,QAAQ;AAAA,EAChB,SAAS,YAAY;AACnB,0CAAoB,UAAU;AAAA,EAChC;AACF;AAUA,eAAsB,YAAe,KAAU,WAAyF;AACtI,QAAM,mBAAmB,MAAM,SAAS,KAAK,SAAS;AACtD,SAAO,IAAI,OAAO,CAAC,GAAG,UAAU,iBAAiB,KAAK,CAAC;AACzD;AAWA,eAAsB,aAAmB,KAAU,UAAoF;AACrI,UAAQ,MAAM,SAAS,KAAK,QAAQ,GAAG,KAAK;AAC9C;AAWA,eAAsB,SAAe,KAAU,UAAkF;AAC/H,SAAO,MAAM,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC;AAC5C;AASO,SAAS,mBAA2C,WAAyE;AAClI,SAAO,IAAI,SAAqB;AAC9B,sBAAkB,MAAM,UAAU,GAAG,IAAI,CAAC;AAAA,EAC5C;AACF;AAUO,SAAS,mBAAmD,QAAuE;AACxI,SAAO,IAAI,SAAgC,QAAQ,QAAQ,EAAE,KAAK,MAAM,OAAO,GAAG,IAAI,CAAC;AACzF;AAOO,SAAS,kBAAkB,SAAuC;AACvE,OAAK,gBAAgB,OAAO;AAC9B;AAQO,SAAS,sBAA4C,OAAwC;AAClG,SAAO,OAAO,OAAO,OAAO,EAAE,kBAAkB,KAAK,CAAmB;AAC1E;AASA,eAAsB,iBAAiB,IAAiC,eAAsC,CAAC,GAAkB;AAC/H,QAAM,iBAAa,4BAAc;AACjC,QAAM,wBAAsC;AAAA,IAC1C,0BAA0B;AAAA,IAC1B,oBAAoB;AAAA,IACpB,uBAAuB;AAAA,EACzB;AACA,QAAM,oBAAkC,EAAE,GAAG,uBAAuB,GAAG,aAAa;AACpF,QAAM,eAAe,kBAAkB,uBAAuB,YAAY;AACxE,QAAI,UAAU;AACd,eAAU;AACR;AACA,UAAI;AACJ,UAAI;AACF,oBAAY,MAAM,GAAG;AAAA,MACvB,SAAS,OAAO;AACd,YAAI,CAAC,kBAAkB,sBAAuB,MAAkC,kBAAkB;AAChG,gBAAM;AAAA,QACR;AACA,qCAAW,KAAK;AAChB,oBAAY;AAAA,MACd;AACA,UAAI,WAAW;AACb,YAAI,UAAU,GAAG;AACf,kBAAQ,MAAM,sCAAsC,QAAQ,SAAS,CAAC,WAAW;AAAA,QACnF;AACA;AAAA,MACF;AAEA,cAAQ,MAAM,iBAAiB,QAAQ,SAAS,CAAC,8CAA8C,kBAAkB,yBAAyB,SAAS,CAAC,iBAAiB;AAAA,QACnK;AAAA,QACA;AAAA,MACF,CAAC;AACD,YAAM,MAAM,kBAAkB,wBAAwB;AAAA,IACxD;AAAA,EACF,CAAC;AACH;AAUA,eAAsB,eAAkB,uBAA+B,IAAuC;AAC5G,MAAI,WAAW;AACf,MAAI,SAAY;AAEhB,QAAM,QAAQ,KAAK,CAAC,IAAI,GAAGA,SAAQ,CAAC,CAAC;AAErC,MAAI,UAAU;AACZ,YAAQ,MAAM,gBAAgB,sBAAsB,SAAS,CAAC,iBAAiB,EAAE,GAAG,CAAC;AACrF,UAAM,IAAI,MAAM,WAAW;AAAA,EAC7B;AACA,SAAO;AAEP,iBAAe,MAAqB;AAClC,aAAS,MAAM,GAAG;AAClB,eAAW;AAAA,EACb;AAEA,iBAAeA,WAAyB;AACtC,UAAM,MAAM,qBAAqB;AACjC,eAAW;AAAA,EACb;AACF;AAQA,eAAsB,MAAM,cAAqC;AAC/D,QAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,YAAY,CAAC;AAClE;AAQA,eAAsB,QAAQ,uBAA+C;AAC3E,QAAM,MAAM,qBAAqB;AACjC,QAAM,IAAI,MAAM,gBAAgB,sBAAsB,SAAS,CAAC,eAAe;AACjF;AASA,eAAsB,QAAW,MAA8C;AAC7E,QAAM,MAAW,CAAC;AAClB,mBAAiB,QAAQ,MAAM;AAC7B,QAAI,KAAK,IAAI;AAAA,EACf;AACA,SAAO;AACT;",
  "names": ["timeout"]
}


package/dist/lib/Async.d.ts

@@ -25,49 +25,50 @@ export interface RetryOptions {
     timeoutInMilliseconds: number;
 }
 /**
- * Retries the provided function until it returns true or the timeout is reached.
- *
- * @param fn - The function to retry.
- * @param retryOptions - Optional parameters to configure the retry behavior.
- * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.
- */
-export declare function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions?: Partial<RetryOptions>): Promise<void>;
-/**
- * Delays execution for a specified number of milliseconds.
- *
- * @param milliseconds - The time to wait in milliseconds.
- * @returns A Promise that resolves after the specified delay.
+ * A marker interface to indicate that an error should terminate retry logic.
  */
-export declare function sleep(milliseconds: number): Promise<void>;
+export interface TerminateRetry {
+    /**
+     * A marker property to indicate that an error should terminate retry logic.
+     */
+    __terminateRetry: true;
+}
 /**
- * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.
+ * Adds an error handler to a Promise that catches any errors and emits an async error event.
  *
- * @typeParam R - The type of the result from the asynchronous function.
- * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.
- * @param fn - The function to execute.
- * @returns A Promise that resolves with the result of the asynchronous function or rejects if it times out.
+ * @param asyncFn - The asynchronous function to add an error handler to.
+ * @returns A Promise that resolves when the asynchronous function completes or emits async error event.
  */
-export declare function runWithTimeout<R>(timeoutInMilliseconds: number, fn: () => MaybePromise<R>): Promise<R>;
+export declare function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void>;
 /**
- * Returns a Promise that rejects after the specified timeout period.
+ * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.
  *
- * @param timeoutInMilliseconds - The timeout period in milliseconds.
- * @returns A Promise that always rejects with a timeout error.
+ * @typeParam T - The type of elements in the input array.
+ * @param arr - The array to filter.
+ * @param predicate - The predicate function to test each element.
+ * @returns A Promise that resolves with an array of elements that satisfy the predicate function.
  */
-export declare function timeout(timeoutInMilliseconds: number): Promise<never>;
+export declare function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => MaybePromise<boolean>): Promise<T[]>;
 /**
- * Invokes a Promise and safely handles any errors by catching them and emitting an async error event.
+ * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.
  *
- * @param asyncFn - The asynchronous function to invoke safely.
+ * @typeParam T - The type of elements in the input array.
+ * @typeParam U - The type of elements in the output array.
+ * @param arr - The array to map over and flatten.
+ * @param callback - The callback function to apply to each element.
+ * @returns A Promise that resolves with a flattened array of the results of the callback function.
  */
-export declare function invokeAsyncSafely(asyncFn: () => Promise<unknown>): void;
+export declare function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U[]>): Promise<U[]>;
 /**
- * Adds an error handler to a Promise that catches any errors and emits an async error event.
+ * Maps over an array asynchronously, applying the provided callback function to each element.
  *
- * @param asyncFn - The asynchronous function to add an error handler to.
- * @returns A Promise that resolves when the asynchronous function completes or emits async error event.
+ * @typeParam T - The type of elements in the input array.
+ * @typeParam U - The type of elements in the output array.
+ * @param arr - The array to map over.
+ * @param callback - The callback function to apply to each element.
+ * @returns A Promise that resolves with an array of the results of the callback function.
  */
-export declare function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void>;
+export declare function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U>): Promise<U[]>;
 /**
  * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.
  *
@@ -86,55 +87,54 @@ export declare function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (.
  */
 export declare function convertSyncToAsync<Args extends unknown[], Result>(syncFn: (...args: Args) => Result): (...args: Args) => Promise<Result>;
 /**
- * Maps over an array asynchronously, applying the provided callback function to each element.
+ * Invokes a Promise and safely handles any errors by catching them and emitting an async error event.
  *
- * @typeParam T - The type of elements in the input array.
- * @typeParam U - The type of elements in the output array.
- * @param arr - The array to map over.
- * @param callback - The callback function to apply to each element.
- * @returns A Promise that resolves with an array of the results of the callback function.
+ * @param asyncFn - The asynchronous function to invoke safely.
  */
-export declare function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U>): Promise<U[]>;
+export declare function invokeAsyncSafely(asyncFn: () => Promise<unknown>): void;
 /**
- * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.
+ * Marks an error to terminate retry logic.
  *
- * @typeParam T - The type of elements in the input array.
- * @param arr - The array to filter.
- * @param predicate - The predicate function to test each element.
- * @returns A Promise that resolves with an array of elements that satisfy the predicate function.
+ * @param error - The error to mark to terminate retry logic.
+ * @returns An error that should terminate retry logic.
  */
-export declare function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => MaybePromise<boolean>): Promise<T[]>;
+export declare function marksAsTerminateRetry<TError extends Error>(error: TError): TerminateRetry & TError;
 /**
- * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.
+ * Retries the provided function until it returns true or the timeout is reached.
  *
- * @typeParam T - The type of elements in the input array.
- * @typeParam U - The type of elements in the output array.
- * @param arr - The array to map over and flatten.
- * @param callback - The callback function to apply to each element.
- * @returns A Promise that resolves with a flattened array of the results of the callback function.
+ * @param fn - The function to retry.
+ * @param retryOptions - Optional parameters to configure the retry behavior.
+ * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.
  */
-export declare function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => MaybePromise<U[]>): Promise<U[]>;
+export declare function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions?: Partial<RetryOptions>): Promise<void>;
 /**
- * Converts an AsyncIterableIterator to an array by consuming all its elements.
+ * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.
  *
- * @typeParam T - The type of elements produced by the AsyncIterableIterator.
- * @param iter - The AsyncIterableIterator to convert.
- * @returns A Promise that resolves with an array of all the elements in the AsyncIterableIterator.
+ * @typeParam R - The type of the result from the asynchronous function.
+ * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.
+ * @param fn - The function to execute.
+ * @returns A Promise that resolves with the result of the asynchronous function or rejects if it times out.
  */
-export declare function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]>;
+export declare function runWithTimeout<R>(timeoutInMilliseconds: number, fn: () => MaybePromise<R>): Promise<R>;
 /**
- * A marker interface to indicate that an error should terminate retry logic.
+ * Delays execution for a specified number of milliseconds.
+ *
+ * @param milliseconds - The time to wait in milliseconds.
+ * @returns A Promise that resolves after the specified delay.
  */
-export interface TerminateRetry {
-    /**
-     * A marker property to indicate that an error should terminate retry logic.
-     */
-    __terminateRetry: true;
-}
+export declare function sleep(milliseconds: number): Promise<void>;
 /**
- * Marks an error to terminate retry logic.
+ * Returns a Promise that rejects after the specified timeout period.
  *
- * @param error - The error to mark to terminate retry logic.
- * @returns An error that should terminate retry logic.
+ * @param timeoutInMilliseconds - The timeout period in milliseconds.
+ * @returns A Promise that always rejects with a timeout error.
  */
-export declare function marksAsTerminateRetry<TError extends Error>(error: TError): TerminateRetry & TError;
+export declare function timeout(timeoutInMilliseconds: number): Promise<never>;
+/**
+ * Converts an AsyncIterableIterator to an array by consuming all its elements.
+ *
+ * @typeParam T - The type of elements produced by the AsyncIterableIterator.
+ * @param iter - The AsyncIterableIterator to convert.
+ * @returns A Promise that resolves with an array of all the elements in the AsyncIterableIterator.
+ */
+export declare function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]>;

package/dist/lib/Blob.cjs

@@ -32,6 +32,16 @@ __export(Blob_exports, {
 });
 module.exports = __toCommonJS(Blob_exports);
 var import_Error = require('./Error.cjs');
+function base64ToArrayBuffer(code) {
+  const parts = code.split(";base64,");
+  const raw = window.atob(parts[1] ?? (0, import_Error.throwExpression)(new Error("Invalid base64 string")));
+  const rawLength = raw.length;
+  const uInt8Array = new Uint8Array(rawLength);
+  for (let i = 0; i < rawLength; ++i) {
+    uInt8Array[i] = raw.charCodeAt(i);
+  }
+  return uInt8Array.buffer;
+}
 async function blobToArrayBuffer(blob) {
   return await new Promise((resolve) => {
     const reader = new FileReader();
@@ -72,16 +82,6 @@ async function blobToJpegArrayBuffer(blob, jpegQuality) {
     reader.readAsDataURL(blob);
   });
 }
-function base64ToArrayBuffer(code) {
-  const parts = code.split(";base64,");
-  const raw = window.atob(parts[1] ?? (0, import_Error.throwExpression)(new Error("Invalid base64 string")));
-  const rawLength = raw.length;
-  const uInt8Array = new Uint8Array(rawLength);
-  for (let i = 0; i < rawLength; ++i) {
-    uInt8Array[i] = raw.charCodeAt(i);
-  }
-  return uInt8Array.buffer;
-}
 function isImageFile(file) {
   return file.type.startsWith("image/");
 }
@@ -92,4 +92,4 @@ function isImageFile(file) {
   blobToJpegArrayBuffer,
   isImageFile
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Blob.d.ts

@@ -2,6 +2,13 @@
  * @packageDocumentation Async
  * Contains utility functions for Blob objects.
  */
+/**
+ * Converts a base64 encoded string to an ArrayBuffer.
+ *
+ * @param code - The base64 encoded string.
+ * @returns The decoded ArrayBuffer.
+ */
+export declare function base64ToArrayBuffer(code: string): ArrayBuffer;
 /**
  * Converts a Blob object to an ArrayBuffer.
  *
@@ -17,13 +24,6 @@ export declare function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
  * @returns A promise that resolves to an ArrayBuffer.
  */
 export declare function blobToJpegArrayBuffer(blob: Blob, jpegQuality: number): Promise<ArrayBuffer>;
-/**
- * Converts a base64 encoded string to an ArrayBuffer.
- *
- * @param code - The base64 encoded string.
- * @returns The decoded ArrayBuffer.
- */
-export declare function base64ToArrayBuffer(code: string): ArrayBuffer;
 /**
  * Checks if a given file is an image.
  *

package/dist/lib/Error.cjs

@@ -37,15 +37,16 @@ var import_eventemitter3 = require('eventemitter3');
 const ASYNC_ERROR_EVENT = "asyncError";
 const asyncErrorEventEmitter = new import_eventemitter3.EventEmitter();
 asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);
-function handleAsyncError(asyncError) {
-  printError(new Error("An unhandled error occurred executing async operation", { cause: asyncError }));
-}
 function emitAsyncErrorEvent(asyncError) {
   asyncErrorEventEmitter.emit(ASYNC_ERROR_EVENT, asyncError);
 }
-function registerAsyncErrorEventHandler(handler) {
-  asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
-  return () => asyncErrorEventEmitter.off(ASYNC_ERROR_EVENT, handler);
+function errorToString(error) {
+  return parseErrorEntries(error).map((entry) => "  ".repeat(entry.level) + entry.message).join("\n");
+}
+function getStackTrace() {
+  const stack = new Error().stack ?? "";
+  const lines = stack.split("\n");
+  return lines.slice(2).join("\n");
 }
 function printError(error) {
   const entries = parseErrorEntries(error);
@@ -57,8 +58,15 @@ function printError(error) {
     }
   }
 }
-function errorToString(error) {
-  return parseErrorEntries(error).map((entry) => "  ".repeat(entry.level) + entry.message).join("\n");
+function registerAsyncErrorEventHandler(handler) {
+  asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
+  return () => asyncErrorEventEmitter.off(ASYNC_ERROR_EVENT, handler);
+}
+function throwExpression(error) {
+  throw error;
+}
+function handleAsyncError(asyncError) {
+  printError(new Error("An unhandled error occurred executing async operation", { cause: asyncError }));
 }
 function parseErrorEntries(error, level = 0, entries = []) {
   if (error === void 0) {
@@ -89,14 +97,6 @@ ${restStack}` });
   }
   return entries;
 }
-function throwExpression(error) {
-  throw error;
-}
-function getStackTrace() {
-  const stack = new Error().stack ?? "";
-  const lines = stack.split("\n");
-  return lines.slice(2).join("\n");
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   emitAsyncErrorEvent,
@@ -106,4 +106,4 @@ function getStackTrace() {
   registerAsyncErrorEventHandler,
   throwExpression
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Error.d.ts

@@ -9,12 +9,18 @@
  */
 export declare function emitAsyncErrorEvent(asyncError: unknown): void;
 /**
- * Registers an event handler for asynchronous errors.
+ * Converts an error to a string representation, including nested causes with indentation.
  *
- * @param handler - The handler function to be called when an asynchronous error event occurs.
- * @returns A function to unregister the handler.
+ * @param error - The error to convert to a string.
+ * @returns The string representation of the error.
  */
-export declare function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void;
+export declare function errorToString(error: unknown): string;
+/**
+ * Gets the current stack trace as a string, excluding the current function call.
+ *
+ * @returns A string representation of the current stack trace, excluding the current function call.
+ */
+export declare function getStackTrace(): string;
 /**
  * Prints an error to the console, including nested causes and optional ANSI sequence clearing.
  *
@@ -22,12 +28,12 @@ export declare function registerAsyncErrorEventHandler(handler: (asyncError: unk
  */
 export declare function printError(error: unknown): void;
 /**
- * Converts an error to a string representation, including nested causes with indentation.
+ * Registers an event handler for asynchronous errors.
  *
- * @param error - The error to convert to a string.
- * @returns The string representation of the error.
+ * @param handler - The handler function to be called when an asynchronous error event occurs.
+ * @returns A function to unregister the handler.
  */
-export declare function errorToString(error: unknown): string;
+export declare function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void;
 /**
  * Throws an error with the specified message.
  *
@@ -35,9 +41,3 @@ export declare function errorToString(error: unknown): string;
  * @returns A never-returning function.
  */
 export declare function throwExpression(error: unknown): never;
-/**
- * Gets the current stack trace as a string, excluding the current function call.
- *
- * @returns A string representation of the current stack trace, excluding the current function call.
- */
-export declare function getStackTrace(): string;