safe-result/lib/collection.d.ts

Create safe results that are either successes or failures

import { FailureResult, SuccessAndFailureResult, SuccessResult } from './result';
import type { ValueType } from './types';
/**
 * Creates a `Promise` that resovles after all values have either resolved or
 * rejected.
 *
 * @note The returned [[SuccessAndFailureResult]] object can indicate being
 * both a `success` and `failure`.
 *
 * If `SuccessAndFailureResult.success` is `true` there are one or more resovled
 * promises.
 *
 * Likewise, if `SuccessAndFailureResult.failure` is `true` there are one or
 * more rejected promises.
 *
 * @example
 *
 * ```ts
 * const args = [
 *   Promise.resolve(success(1)),
 *   Promise.resolve(success(2)),
 *   Promise.reject(failure(new Error('First failure'))),
 * ]
 *
 * const res = await Result.allSettled(args)
 *
 * if (res.success) { // Will be `true` in this case
 *   console.log('Values:', res.result.join(', '))
 *   // Values: 1, 2
 * }
 *
 * if (res.failure) { // Will also be true in this case
 *   console.error('Errors:', res.error.map((e) => e.message).join(', '))
 *   // Errors: First failure
 * }
 * ```
 *
 * @param values
 */
export declare function allSettled<T>(values: Array<T | Promise<T>>): Promise<SuccessAndFailureResult<ValueType<T>[], Error[]>>;
/**
 * Creates a `Promise` that resolves to either a [[SuccessResult]] or a
 * [[FailureResult]].
 *
 * This behaves pretty much the same as `Promise.all()`, so it will abort and
 * return a [[FailureResult]] as soon as a value is a rejected value.
 *
 * @example _Example with all resolved promises_
 *
 * ```ts
 * const values = [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)]
 * const [res, err] = (await Result.all(values)).unwrap()
 *
 * if (err) { // This will never be `true` in this case
 *   return
 * }
 *
 * console.log(
 *   res.map((num) => `Result ${num}`).join(', ')
 * )
 *
 * // Result 1, Result 2, Result 3
 * ```
 *
 * @example _Example where one or more promises are rejected_
 *
 * ```ts
 * const values = [Promise.resolve(1), Promise.reject(2), Promise.resolve(3)]
 * const [res, err] = (await Result.all(values)).unwrap()
 *
 * if (err) { // This will always be `true` in this case
 *   console.error('An error occured:', err.message)
 *   return
 * }
 * ```
 *
 * @param values
 */
export declare function all<T>(values: (T | PromiseLike<T>)[]): Promise<SuccessResult<ValueType<T>[]> | FailureResult>;
//# sourceMappingURL=collection.d.ts.map