resultar 0.6.1 → 0.8.0

package/dist/index-BsQaA54t.d.cts

@@ -1,205 +0,0 @@
-declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
-    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-    private readonly innerPromise;
-    constructor(res: Promise<Result<T, E>>);
-    then<A, B>(// eslint-disable-line unicorn/no-thenable
-    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
-    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
-    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
-    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
-    andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
-    match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X>;
-    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
-    /**
-     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-     */
-    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
-}
-declare function fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-declare function fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
-declare function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
-declare function fromThrowableAsync<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
-declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
-
-declare class Result<T, E> {
-    private readonly state;
-    /**
-     * Wraps a function with a try catch, creating a new function with the same
-     * arguments but returning `Ok` if successful, `Err` if the function throws
-     *
-     * @param fn function to wrap with ok on success or err on failure
-     * @param errorFn when an error is thrown, this will wrap the error result if provided
-     */
-    static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: (e: any) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
-    static ok<T, E = never>(value: T): Result<T, E>;
-    static err<T = never, E = unknown>(error: E): Result<T, E>;
-    readonly value: T;
-    readonly error: E;
-    private constructor();
-    /**
-     * Used to check if a `Result` is an `OK`
-     *
-     * @returns `true` if the result is an `OK` variant of Result
-     */
-    isOk(): boolean;
-    /**
-     * Used to check if a `Result` is an `Err`
-     *
-     * @returns `true` if the result is an `Err` variant of Result
-     */
-    isErr(): boolean;
-    /**
-     * Maps a `Result<T, E>` to `Result<U, E>`
-     * by applying a function to a contained `Ok` value, leaving an `Err` value
-     * untouched.
-     *
-     * @param f The function to apply an `OK` value
-     * @returns the result of applying `f` or an `Err` untouched
-     */
-    map<X, Y>(f: (t: T) => Exclude<X, Promise<any>>): Result<X, E | Y>;
-    /**
-     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
-     * contained `Err` value, leaving an `Ok` value untouched.
-     *
-     * This function can be used to pass through a successful result while
-     * handling an error.
-     *
-     * @param f a function to apply to the error `Err` value
-     */
-    mapErr<X>(fn: (t: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X>;
-    /**
-     * Similar to `map` Except you must return a new `Result`.
-     *
-     * This is useful for when you need to do a subsequent computation using the
-     * inner `T` value, but that computation might fail.
-     * Additionally, `andThen` is really useful as a tool to flatten a
-     * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
-     *
-     * @param f The function to apply to the current value
-     */
-    andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>;
-    /**
-     * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
-     *
-     * This is useful for error recovery.
-     *
-     *
-     * @param f  A function to apply to an `Err` value, leaving `Ok` values
-     * untouched.
-     */
-    orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, Y>;
-    /**
-     * Similar to `map` Except you must return a new `Result`.
-     *
-     * This is useful for when you need to do a subsequent async computation using
-     * the inner `T` value, but that computation might fail. Must return a ResultAsync
-     *
-     * @param f The function that returns a `ResultAsync` to apply to the current
-     * value
-     */
-    asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
-    /**
-     * Maps a `Result<T, E>` to `ResultAsync<U, E>`
-     * by applying an async function to a contained `Ok` value, leaving an `Err`
-     * value untouched.
-     *
-     * @param f An async function to apply an `OK` value
-     */
-    asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E>;
-    /**
-     * Unwrap the `Ok` value, or return the default if there is an `Err`
-     *
-     * @param v the default value to return if there is an `Err`
-     */
-    unwrapOr<A>(defaultValue: A): T | A;
-    /**
-     *
-     * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
-     * execute the function that matches the `Result` variant.
-     *
-     * Match callbacks do not necessitate to return a `Result`, however you can
-     * return a `Result` if you want to.
-     *
-     * `match` is like chaining `map` and `mapErr`, with the distinction that
-     * with `match` both functions must have the same return type.
-     *
-     * @param ok
-     * @param err
-     */
-    match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
-    /**
-     * Performs a side effect for the `Ok` variant of `Result`.
-     *
-     * @param f The function to apply an `OK` value
-     * @returns the result of applying `f` or an `Err` untouched
-     */
-    tap(f: (t: T) => void): Result<T, E>;
-    /**
-     * **This method is unsafe, and should only be used in a test environments**
-     *
-     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
-     *
-     * @param config
-     */
-    _unsafeUnwrap(config?: ErrorConfig): T;
-    /**
-     * **This method is unsafe, and should only be used in a test environments**
-     *
-     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
-     * otherwise it throws a custom object.
-     *
-     * @param config
-     */
-    _unsafeUnwrapErr(config?: ErrorConfig): E;
-    safeUnwrap(): Generator<Result<never, E>, T>;
-}
-declare const ok: <T, E = never>(value: T) => Result<T, E>;
-declare const err: <T = never, E = unknown>(error: E) => Result<T, E>;
-declare const fromThrowable: <Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: ((e: any) => E) | undefined) => (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
-/**
- * Evaluates the given generator to a Result returned or an Err yielded from it,
- * whichever comes first.
- *
- * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
- * Rust's ? operator.
- * See `/tests/safeTry.test.ts` for examples.
- *
- * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
- * Rust's `result?` expression.
- * @returns The first occurence of either an yielded Err or a returned Result.
- */
-declare function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>;
-/**
- * Evaluates the given generator to a Result returned or an Err yielded from it,
- * whichever comes first.
- *
- * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
- * Rust's ? operator.
- * See `/tests/safeTry.test.ts` for examples.
- *
- * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` and
- * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.
- * @returns The first occurence of either an yielded Err or a returned Result.
- */
-declare function safeTry<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): Promise<Result<T, E>>;
-
-interface ErrorConfig {
-    withStackTrace: boolean;
-}
-interface ResultarError<T, E> {
-    data: {
-        type: string;
-        value: T | undefined;
-    } | {
-        type: string;
-        value: E | undefined;
-    };
-    message: string;
-    stack: string | undefined;
-}
-declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
-
-export { type ErrorConfig as E, ResultAsync as R, fromPromise as a, fromThrowableAsync as b, Result as c, ok as d, errAsync as e, fromSafePromise as f, err as g, fromThrowable as h, safeTry as i, createResultarError as j, okAsync as o, safeTryAsync as s };

package/dist/index-BsQaA54t.d.ts

@@ -1,205 +0,0 @@
-declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
-    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-    private readonly innerPromise;
-    constructor(res: Promise<Result<T, E>>);
-    then<A, B>(// eslint-disable-line unicorn/no-thenable
-    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
-    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
-    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
-    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
-    andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
-    match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X>;
-    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
-    /**
-     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-     */
-    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
-}
-declare function fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-declare function fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
-declare function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
-declare function fromThrowableAsync<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
-declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
-
-declare class Result<T, E> {
-    private readonly state;
-    /**
-     * Wraps a function with a try catch, creating a new function with the same
-     * arguments but returning `Ok` if successful, `Err` if the function throws
-     *
-     * @param fn function to wrap with ok on success or err on failure
-     * @param errorFn when an error is thrown, this will wrap the error result if provided
-     */
-    static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: (e: any) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
-    static ok<T, E = never>(value: T): Result<T, E>;
-    static err<T = never, E = unknown>(error: E): Result<T, E>;
-    readonly value: T;
-    readonly error: E;
-    private constructor();
-    /**
-     * Used to check if a `Result` is an `OK`
-     *
-     * @returns `true` if the result is an `OK` variant of Result
-     */
-    isOk(): boolean;
-    /**
-     * Used to check if a `Result` is an `Err`
-     *
-     * @returns `true` if the result is an `Err` variant of Result
-     */
-    isErr(): boolean;
-    /**
-     * Maps a `Result<T, E>` to `Result<U, E>`
-     * by applying a function to a contained `Ok` value, leaving an `Err` value
-     * untouched.
-     *
-     * @param f The function to apply an `OK` value
-     * @returns the result of applying `f` or an `Err` untouched
-     */
-    map<X, Y>(f: (t: T) => Exclude<X, Promise<any>>): Result<X, E | Y>;
-    /**
-     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
-     * contained `Err` value, leaving an `Ok` value untouched.
-     *
-     * This function can be used to pass through a successful result while
-     * handling an error.
-     *
-     * @param f a function to apply to the error `Err` value
-     */
-    mapErr<X>(fn: (t: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X>;
-    /**
-     * Similar to `map` Except you must return a new `Result`.
-     *
-     * This is useful for when you need to do a subsequent computation using the
-     * inner `T` value, but that computation might fail.
-     * Additionally, `andThen` is really useful as a tool to flatten a
-     * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
-     *
-     * @param f The function to apply to the current value
-     */
-    andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>;
-    /**
-     * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
-     *
-     * This is useful for error recovery.
-     *
-     *
-     * @param f  A function to apply to an `Err` value, leaving `Ok` values
-     * untouched.
-     */
-    orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, Y>;
-    /**
-     * Similar to `map` Except you must return a new `Result`.
-     *
-     * This is useful for when you need to do a subsequent async computation using
-     * the inner `T` value, but that computation might fail. Must return a ResultAsync
-     *
-     * @param f The function that returns a `ResultAsync` to apply to the current
-     * value
-     */
-    asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
-    /**
-     * Maps a `Result<T, E>` to `ResultAsync<U, E>`
-     * by applying an async function to a contained `Ok` value, leaving an `Err`
-     * value untouched.
-     *
-     * @param f An async function to apply an `OK` value
-     */
-    asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E>;
-    /**
-     * Unwrap the `Ok` value, or return the default if there is an `Err`
-     *
-     * @param v the default value to return if there is an `Err`
-     */
-    unwrapOr<A>(defaultValue: A): T | A;
-    /**
-     *
-     * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
-     * execute the function that matches the `Result` variant.
-     *
-     * Match callbacks do not necessitate to return a `Result`, however you can
-     * return a `Result` if you want to.
-     *
-     * `match` is like chaining `map` and `mapErr`, with the distinction that
-     * with `match` both functions must have the same return type.
-     *
-     * @param ok
-     * @param err
-     */
-    match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
-    /**
-     * Performs a side effect for the `Ok` variant of `Result`.
-     *
-     * @param f The function to apply an `OK` value
-     * @returns the result of applying `f` or an `Err` untouched
-     */
-    tap(f: (t: T) => void): Result<T, E>;
-    /**
-     * **This method is unsafe, and should only be used in a test environments**
-     *
-     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
-     *
-     * @param config
-     */
-    _unsafeUnwrap(config?: ErrorConfig): T;
-    /**
-     * **This method is unsafe, and should only be used in a test environments**
-     *
-     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
-     * otherwise it throws a custom object.
-     *
-     * @param config
-     */
-    _unsafeUnwrapErr(config?: ErrorConfig): E;
-    safeUnwrap(): Generator<Result<never, E>, T>;
-}
-declare const ok: <T, E = never>(value: T) => Result<T, E>;
-declare const err: <T = never, E = unknown>(error: E) => Result<T, E>;
-declare const fromThrowable: <Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: ((e: any) => E) | undefined) => (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
-/**
- * Evaluates the given generator to a Result returned or an Err yielded from it,
- * whichever comes first.
- *
- * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
- * Rust's ? operator.
- * See `/tests/safeTry.test.ts` for examples.
- *
- * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
- * Rust's `result?` expression.
- * @returns The first occurence of either an yielded Err or a returned Result.
- */
-declare function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>;
-/**
- * Evaluates the given generator to a Result returned or an Err yielded from it,
- * whichever comes first.
- *
- * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
- * Rust's ? operator.
- * See `/tests/safeTry.test.ts` for examples.
- *
- * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` and
- * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.
- * @returns The first occurence of either an yielded Err or a returned Result.
- */
-declare function safeTry<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): Promise<Result<T, E>>;
-
-interface ErrorConfig {
-    withStackTrace: boolean;
-}
-interface ResultarError<T, E> {
-    data: {
-        type: string;
-        value: T | undefined;
-    } | {
-        type: string;
-        value: E | undefined;
-    };
-    message: string;
-    stack: string | undefined;
-}
-declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
-
-export { type ErrorConfig as E, ResultAsync as R, fromPromise as a, fromThrowableAsync as b, Result as c, ok as d, errAsync as e, fromSafePromise as f, err as g, fromThrowable as h, safeTry as i, createResultarError as j, okAsync as o, safeTryAsync as s };