trysafely/dist/index.js

A robust async helper to wrap promises and functions, returning [result, error] for graceful error handling.

/**

- Attempts to run an **async** function safely.
- @template T
- @param fn - A function returning a Promise.
- @returns An object `{ data, err }` where `data` is the resolved value or `null`, and `err` is the caught error or `null`.
   */
export async function tryAsync(fn) {
    try {
        const data = await fn();
        return { data, err: null };
    }
    catch (error) {
        const err = error instanceof Error ? error : new Error(String(error));
        return { data: null, err };
    }
}
/**

- Attempts to run a **sync** function safely.
- @template T
- @param fn - A function returning a synchronous result.
- @returns An object `{ data, err }`
   */
export function trySync(fn) {
    try {
        const data = fn();
        return { data, err: null };
    }
    catch (error) {
        const err = error instanceof Error ? error : new Error(String(error));
        return { data: null, err };
    }
}
/**

- Attempts to run a function safely, whether it returns a value or a promise.
- @template T - The type of the function's return value.
- @param fn - A function that returns either T or Promise.
- @returns A Promise resolving to `{ data, err }`.
   */
export default async function trySafely(fn) {
    if (typeof fn !== "function") {
        throw new Error("fn must be a function");
    }
    try {
        const res = fn();
        // If the result is a Promise-like, await it
        const isThenable = res !== null && typeof res.then === "function";
        if (isThenable) {
            const data = await res;
            return { data, err: null };
        }
        const data = res;
        return { data, err: null };
    }
    catch (error) {
        const err = error instanceof Error ? error : new Error(String(error));
        return { data: null, err };
    }
}
//# sourceMappingURL=index.js.map