obsidian-dev-utils 88.8.0 → 89.0.0

package/dist/lib/esm/async.d.mts

@@ -42,67 +42,67 @@ export interface RetryOptions {
 /**
  * Adds an error handler to a {@link Promise} that catches any errors and emits an async error event.
  *
- * @param asyncFn - The asynchronous function to add an error handler to.
+ * @param asyncFunction - The asynchronous function to add an error handler to.
  * @param stackTrace - The stack trace of the source function.
  * @returns A {@link Promise} that resolves when the asynchronous function completes or emits async error event.
  */
-export declare function addErrorHandler(asyncFn: () => Promise<unknown>, stackTrace?: string): Promise<void>;
+export declare function addErrorHandler(asyncFunction: () => Promise<unknown>, stackTrace?: string): Promise<void>;
 /**
  * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.
  *
  * @typeParam T - The type of elements in the input array.
- * @param arr - The array to filter.
+ * @param array - The array to filter.
  * @param predicate - The predicate function to test each element.
  * @returns A {@link Promise} that resolves with an array of elements that satisfy the predicate function.
  */
-export declare function asyncFilter<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]>;
+export declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]>;
 /**
  * Filters an array asynchronously in place, keeping only the elements that satisfy the provided predicate function.
  *
  * @typeParam T - The type of elements in the input array.
- * @param arr - The array to filter.
+ * @param array - The array to filter.
  * @param predicate - The predicate function to test each element.
  * @returns A {@link Promise} that resolves when the array is filtered.
  */
-export declare function asyncFilterInPlace<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<void>;
+export declare function asyncFilterInPlace<T>(array: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<void>;
 /**
  * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.
  *
  * @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 array - The array to map over and flatten.
  * @param callback - The callback function to apply to each element.
  * @returns A {@link Promise} that resolves with a flattened array of the results of the callback function.
  */
-export declare function asyncFlatMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]>;
+export declare function asyncFlatMap<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]>;
 /**
  * Maps over an array asynchronously, applying the provided callback function to each element.
  *
  * @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 array - The array to map over.
  * @param callback - The callback function to apply to each element.
  * @returns A {@link Promise} that resolves with an array of the results of the callback function.
  */
-export declare function asyncMap<T, U>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]>;
+export declare function asyncMap<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]>;
 /**
  * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.
  *
- * @typeParam Args - The types of the arguments the function accepts.
- * @param asyncFunc - The asynchronous function to convert.
+ * @typeParam Arguments - The types of the arguments the function accepts.
+ * @param asyncFunction - The asynchronous function to convert.
  * @param stackTrace - The stack trace of the source function.
  * @returns A function that wraps the asynchronous function in a synchronous interface.
  */
-export declare function convertAsyncToSync<Args extends unknown[]>(asyncFunc: GenericAsyncFunction<Args>, stackTrace?: string): GenericVoidFunction<Args>;
+export declare function convertAsyncToSync<Arguments extends unknown[]>(asyncFunction: GenericAsyncFunction<Arguments>, stackTrace?: string): GenericVoidFunction<Arguments>;
 /**
  * Converts a synchronous function to an asynchronous one by wrapping it in a {@link Promise}.
  *
- * @typeParam Args - The types of the arguments the function accepts.
+ * @typeParam Arguments - The types of the arguments the function accepts.
  * @typeParam Result - The type of the function's return value.
- * @param syncFn - The synchronous function to convert.
+ * @param syncFunction - The synchronous function to convert.
  * @returns A function that wraps the synchronous function in an asynchronous interface.
  */
-export declare function convertSyncToAsync<Args extends unknown[], Result>(syncFn: GenericFunction<Args, Result>): GenericAsyncFunction<Args, Result>;
+export declare function convertSyncToAsync<Arguments extends unknown[], Result>(syncFunction: GenericFunction<Arguments, Result>): GenericAsyncFunction<Arguments, Result>;
 /**
  * Handles a silent error.
  *
@@ -140,7 +140,7 @@ export interface InvokeAsyncSafelyAfterDelayParams {
      *
      * @param abortSignal - The abort signal to listen to.
      */
-    asyncFn(this: void, abortSignal: AbortSignal): Promisable<void>;
+    asyncFunction(this: void, abortSignal: AbortSignal): Promisable<void>;
     /**
      * The delay in milliseconds.
      *
@@ -169,10 +169,10 @@ export declare function enableAsyncOperationTracking(): Disposable;
 /**
  * Invokes a {@link Promise} and safely handles any errors by catching them and emitting an async error event.
  *
- * @param asyncFn - The asynchronous function to invoke safely.
+ * @param asyncFunction - The asynchronous function to invoke safely.
  * @param stackTrace - The stack trace of the source function.
  */
-export declare function invokeAsyncSafely(asyncFn: () => Promisable<unknown>, stackTrace?: string): void;
+export declare function invokeAsyncSafely(asyncFunction: () => Promisable<unknown>, stackTrace?: string): void;
 /**
  * Invokes an asynchronous function after a delay.
  *
@@ -226,7 +226,7 @@ export interface RetryWithTimeoutParams {
      * @param abortSignal - The abort signal to listen to.
      * @returns The result of the function.
      */
-    operationFn(this: void, abortSignal: AbortSignal): Promisable<boolean>;
+    operationFunction(this: void, abortSignal: AbortSignal): Promisable<boolean>;
     /**
      * The name of the operation.
      *
@@ -264,7 +264,7 @@ export interface RunWithTimeoutParams<Result> {
      * @param abortSignal - The abort signal to listen to.
      * @returns The result of the function.
      */
-    operationFn(this: void, abortSignal: AbortSignal): Promisable<Result>;
+    operationFunction(this: void, abortSignal: AbortSignal): Promisable<Result>;
     /**
      * The name of the operation.
      *
@@ -345,10 +345,10 @@ export interface TimeoutParams {
  * Chains a promise with another promise.
  *
  * @param chainPromise - Represents the chained promise.
- * @param promisableFn - The function to chain.
+ * @param promisableFunction - The function to chain.
  * @returns Chained promise or `null` if no async logic is chained.
  */
-export declare function chain(chainPromise: null | Promise<void>, promisableFn: () => null | Promisable<void>): null | Promise<void>;
+export declare function chain(chainPromise: null | Promise<void>, promisableFunction: () => null | Promisable<void>): null | Promise<void>;
 /**
  * Marks an error to terminate retry logic.
  *