@replyke/core/dist/esm/hooks/entities/useFetchManyEntitiesWrapper.js

Replyke: Build interactive apps with social features like comments, votes, feeds, user lists, notifications, and more.

import { useCallback, useEffect, useRef, useState } from "react";
import useFetchManyEntities from "./useFetchManyEntities";
import { handleError } from "../../utils/handleError";
function useFetchManyEntitiesWrapper(props) {
    const { userId, limit = 10, defaultSortBy = "new", defaultSortByReaction = "upvote", defaultSortDir = "desc", defaultSortType = "auto", timeFrame, sourceId, spaceId, include, followedOnly, keywordsFilters, titleFilters, contentFilters, attachmentsFilters, locationFilters, metadataFilters, } = props;
    const fetchManyEntities = useFetchManyEntities();
    const loading = useRef(true);
    const [loadingState, setLoadingState] = useState(true);
    const hasMore = useRef(true);
    const [hasMoreState, setHasMoreState] = useState(true);
    const [sortBy, setSortBy] = useState(defaultSortBy);
    const [sortByReaction, setSortByReaction] = useState(defaultSortByReaction);
    const [sortDir, setSortDir] = useState(defaultSortDir);
    const [sortType, setSortType] = useState(defaultSortType);
    const [page, setPage] = useState(1);
    const [entities, setEntities] = useState([]);
    const resetEntities = useCallback(async () => {
        try {
            loading.current = true;
            setLoadingState(true);
            hasMore.current = true;
            setHasMoreState(true);
            setPage(1);
            const response = await fetchManyEntities({
                userId,
                page: 1,
                sortBy,
                sortByReaction,
                sortDir,
                sortType,
                timeFrame,
                sourceId,
                spaceId,
                limit,
                include,
                followedOnly,
                keywordsFilters,
                titleFilters,
                contentFilters,
                attachmentsFilters,
                locationFilters,
                metadataFilters,
            });
            if (response) {
                const { data: newEntities, pagination } = response;
                setEntities(newEntities);
                hasMore.current = pagination.hasMore;
                setHasMoreState(pagination.hasMore);
            }
        }
        catch (err) {
            handleError(err, "Failed to reset profile entities:");
        }
        finally {
            loading.current = false;
            setLoadingState(false);
        }
    }, [
        fetchManyEntities,
        limit,
        sortBy,
        sortByReaction,
        sortDir,
        sortType,
        timeFrame,
        sourceId,
        spaceId,
        userId,
        include,
        followedOnly,
        keywordsFilters,
        titleFilters,
        contentFilters,
        attachmentsFilters,
        locationFilters,
        metadataFilters,
    ]);
    const loadMore = () => {
        if (loading.current || !hasMore.current)
            return;
        setPage((prevPage) => {
            return prevPage + 1;
        });
    };
    useEffect(() => {
        resetEntities();
    }, [resetEntities]);
    // useEffect to get a new batch of entities
    useEffect(() => {
        const loadMoreEntities = async () => {
            loading.current = true;
            setLoadingState(true);
            try {
                const response = await fetchManyEntities({
                    userId,
                    page,
                    sortBy,
                    sortByReaction,
                    sortDir,
                    sortType,
                    timeFrame,
                    sourceId,
                    spaceId,
                    limit,
                    include,
                    followedOnly,
                    keywordsFilters,
                    titleFilters,
                    contentFilters,
                    attachmentsFilters,
                    locationFilters,
                    metadataFilters,
                });
                if (response) {
                    const { data: newEntities, pagination } = response;
                    setEntities((prevEntities) => [...prevEntities, ...newEntities]);
                    hasMore.current = pagination.hasMore;
                    setHasMoreState(pagination.hasMore);
                }
            }
            catch (err) {
                handleError(err, "Loading more entities failed:");
            }
            finally {
                loading.current = false;
                setLoadingState(false);
            }
        };
        // We only load more if the page changed
        if (page > 1 && hasMore.current && !loading.current) {
            loadMoreEntities();
        }
    }, [
        page,
        fetchManyEntities,
        userId,
        sortBy,
        sortByReaction,
        sortDir,
        sortType,
        timeFrame,
        sourceId,
        spaceId,
        limit,
        include,
        followedOnly,
        keywordsFilters,
        titleFilters,
        contentFilters,
        attachmentsFilters,
        locationFilters,
        metadataFilters,
    ]);
    return {
        entities,
        loading: loadingState,
        hasMore: hasMoreState,
        sortBy,
        sortByReaction,
        sortDir,
        sortType,
        setSortBy,
        setSortByReaction,
        setSortDir,
        setSortType,
        loadMore,
    };
}
export default useFetchManyEntitiesWrapper;
//# sourceMappingURL=useFetchManyEntitiesWrapper.js.map