@hazae41/glacier/dist/esm/src/mods/fetched/fetched.mjs

Yet another React data (re)fetching library

import { Catched } from '@hazae41/result';
import { Data } from './data.mjs';
import { Fail } from './fail.mjs';

var Fetched;
(function (Fetched) {
    function from(init) {
        if ("error" in init)
            return Fail.from(init);
        else
            return Data.from(init);
    }
    Fetched.from = from;
    function rewrap(result, init = result) {
        if (result.isErr())
            return new Fail(result.getErr(), init);
        else
            return new Data(result.get(), init);
    }
    Fetched.rewrap = rewrap;
    /**
     * Run a callback and wrap any returned value in Ok<T> and any thrown error in Err<unknown>
     * @param callback
     * @returns
     */
    async function runAndWrap(callback, init) {
        try {
            return new Data(await callback(), init);
        }
        catch (e) {
            return new Fail(e, init);
        }
    }
    Fetched.runAndWrap = runAndWrap;
    /**
     * Run a callback and wrap any returned value in Ok<T> and any thrown error in Err<unknown>
     * @param callback
     * @returns
     */
    function runAndWrapSync(callback, init) {
        try {
            return new Data(callback(), init);
        }
        catch (e) {
            return new Fail(e, init);
        }
    }
    Fetched.runAndWrapSync = runAndWrapSync;
    /**
     * Run a callback and wrap any returned value in Ok<T> and any thrown error in Err<Catched>
     * @param callback
     * @returns
     */
    async function runAndDoubleWrap(callback, init) {
        try {
            return new Data(await callback(), init);
        }
        catch (e) {
            return new Fail(Catched.wrap(e), init);
        }
    }
    Fetched.runAndDoubleWrap = runAndDoubleWrap;
    /**
     * Run a callback and wrap any returned value in Ok<T> and any thrown error in Err<Catched>
     * @param callback
     * @returns
     */
    function runAndDoubleWrapSync(callback, init) {
        try {
            return new Data(callback(), init);
        }
        catch (e) {
            return new Fail(Catched.wrap(e), init);
        }
    }
    Fetched.runAndDoubleWrapSync = runAndDoubleWrapSync;
    /**
     * Run a callback and wrap any thrown error in Err<unknown>
     * @param callback
     * @returns
     */
    async function runOrWrap(callback, init) {
        try {
            return await callback();
        }
        catch (e) {
            return new Fail(e, init);
        }
    }
    Fetched.runOrWrap = runOrWrap;
    /**
     * Run a callback and wrap any thrown error in Err<unknown>
     * @param callback
     * @returns
     */
    function runOrWrapSync(callback, init) {
        try {
            return callback();
        }
        catch (e) {
            return new Fail(e, init);
        }
    }
    Fetched.runOrWrapSync = runOrWrapSync;
    /**
     * Run a callback and wrap any thrown error in Err<unknown>
     * @param callback
     * @returns
     */
    async function runOrDoubleWrap(callback, init) {
        try {
            return await callback();
        }
        catch (e) {
            return new Fail(Catched.wrap(e), init);
        }
    }
    Fetched.runOrDoubleWrap = runOrDoubleWrap;
    /**
     * Run a callback and wrap any thrown error in Err<unknown>
     * @param callback
     * @returns
     */
    function runOrDoubleWrapSync(callback, init) {
        try {
            return callback();
        }
        catch (e) {
            return new Fail(Catched.wrap(e), init);
        }
    }
    Fetched.runOrDoubleWrapSync = runOrDoubleWrapSync;
})(Fetched || (Fetched = {}));

export { Fetched };
//# sourceMappingURL=fetched.mjs.map