atomico/cjs/use-lazy.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require('./chunk/constants.js');
var utils = require('./chunk/utils.js');
var core = require('./core.js');

let def = "default";

let typeLoading = "loading";

let typeResolve = "resolve";

let typeReject = "reject";

let defMsLoading = 100;

let WhenLoading = () => ({ loading, ...props }) =>
    utils.isFunction(loading) ? loading(props) : loading;

let WhenError = () => ({ error = "", ...props }) =>
    utils.isFunction(error) ? error(props) : error;

let WhenEmpty = () => () => "";

/**
 * It allows to load a component asynchronously.
 * @param {Function} callback
 * @param {object} [props]
 *
 * @todo add promise error detection behavior
 */
function useLazy(callback, args = [], msLoading = defMsLoading) {
    let [Component, setComponent] = core.useState(WhenEmpty);
    core.useEffect(() => {
        let cancel;
        let ready;

        callback()
            .then(data => {
                ready = true;
                if (!cancel) {
                    let value = def in data ? data[def] : data;
                    setComponent(() => props =>
                        utils.isFunction(value) ? value(props) : value
                    );
                }
            })
            .catch(() => {
                ready = true;
                if (!cancel) setComponent(WhenError);
            });

        setTimeout(
            () => !cancel && !ready && setComponent(WhenLoading),
            msLoading
        );
        return () => {
            cancel = true;
            if (ready) setComponent(() => WhenEmpty);
        };
    }, args);

    return Component;
}

function useLazyNode(callback, msLoading = defMsLoading) {
    let [prevent, setPrevent] = core.useState(true);
    let [status, setStatus] = core.useState();
    let [Component, setComponent] = core.useState(WhenEmpty);

    function CaseProxy(props) {
        if (prevent) setPrevent(prevent => (prevent ? false : prevent));
        return status == typeLoading
            ? WhenLoading()(props)
            : status == typeResolve
            ? Component(props)
            : status == typeReject
            ? WhenError()(props)
            : WhenEmpty()();
    }

    core.useEffect(() => {
        if (!prevent) {
            callback()
                .then(md => {
                    setStatus(typeResolve);
                    setComponent(() => (def in md ? md[def] : md));
                })
                .catch(e => setStatus(typeReject));
            setTimeout(
                () =>
                    setStatus(status =>
                        [typeLoading, typeReject, typeResolve].includes(status)
                            ? status
                            : typeLoading
                    ),
                msLoading
            );
        }
    }, [prevent]);

    return CaseProxy;
}

exports.useLazy = useLazy;
exports.useLazyNode = useLazyNode;
//# sourceMappingURL=use-lazy.js.map