@hazae41/glacier/dist/cjs/src/mods/fetched/fetched.cjs

Yet another React data (re)fetching library

'use strict';

var result = require('@hazae41/result');
var data = require('./data.cjs');
var fail = require('./fail.cjs');

exports.Fetched = void 0;
(function (Fetched) {
    function from(init) {
        if ("error" in init)
            return fail.Fail.from(init);
        else
            return data.Data.from(init);
    }
    Fetched.from = from;
    function rewrap(result, init = result) {
        if (result.isErr())
            return new fail.Fail(result.getErr(), init);
        else
            return new data.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.Data(await callback(), init);
        }
        catch (e) {
            return new fail.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.Data(callback(), init);
        }
        catch (e) {
            return new fail.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.Data(await callback(), init);
        }
        catch (e) {
            return new fail.Fail(result.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.Data(callback(), init);
        }
        catch (e) {
            return new fail.Fail(result.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.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.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.Fail(result.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.Fail(result.Catched.wrap(e), init);
        }
    }
    Fetched.runOrDoubleWrapSync = runOrDoubleWrapSync;
})(exports.Fetched || (exports.Fetched = {}));
//# sourceMappingURL=fetched.cjs.map