@ludo.ninja/components 2.3.36 → 2.3.37

package/build/hooks/galleries/useGetUserGalleriesCreations/index.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetUserGalleriesCreations = void 0;
+exports.getMediaForGallery = getMediaForGallery;
+const builder_1 = require("../../../entities/creation/builder");
+const collectionCreationBuilder_1 = require("../../../entities/creation/collectionCreationBuilder");
+const builder_2 = require("../../../entities/gallery/builder");
+const ui_1 = require("../../../store/ui");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const schema_1 = require("@ludo.ninja/api/build/graphql_tools/__generated__/galleriesHost/schema");
+const schema_2 = require("@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema");
+const react_1 = require("react");
+const getErrorAlertProps_1 = require("../../../utils/getErrorAlertProps");
+const maxUserFavoritesLength = 1000;
+const useGetUserGalleriesCreations = ({ userId, pageSize, pageToken }) => {
+    const [assets, setAsset] = (0, react_1.useState)(null);
+    const [collections, setCollections] = (0, react_1.useState)(null);
+    const [galleries, setGalleries] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const nextPageToken = (0, react_1.useRef)(null);
+    const [isNextLoading, setIsNextLoading] = (0, react_1.useState)(false); // todo: after update api , get isNextPage from results
+    // const isHaveNextPage = favorites.length < results;
+    const isHaveNextPage = !!nextPageToken.current;
+    const { loading: favoritesLoading, error: galleriesError, refetch, fetchMore, } = (0, client_1.useQuery)(schema_1.FetchUserGalleriesV2Document, {
+        context: { uri: api_1.hosts.galleriesHost },
+        variables: { pageSize, userId, pageToken },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchUserGalleriesV2: { galleries, nextPageToken: token } }) => {
+            // nextPageToken.current = nextPage.nextPage?.token || null;
+            nextPageToken.current = token || null;
+            setGalleries(galleries.map((gallery) => (0, builder_2.buildGallery)(gallery)));
+            setLoading(false);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setGalleries([]);
+            setLoading(false);
+        },
+    });
+    const [fetchAssets, { loading: assetsLoading, error: assetsError }] = (0, client_1.useLazyQuery)(schema_2.FetchAssetsDocument, {
+        context: { uri: api_1.hosts.searchHost },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchAssets: data }) => {
+            setAsset(data.map((asset) => (0, builder_1.buildCreation)({
+                ...asset,
+                itemType: "asset",
+                itemId: asset.assetId,
+            })));
+            setLoading(false);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setAsset(null);
+            setLoading(false);
+        },
+    });
+    const [fetchCollections, { loading: collectionsLoading, error: collectionsError }] = (0, client_1.useLazyQuery)(schema_2.FetchCollectionsByIdsDocument, {
+        context: { uri: api_1.hosts.searchHost },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchCollectionsByIds: data }) => {
+            setCollections(data.map((collection) => (0, collectionCreationBuilder_1.buildCollectionCreation)(collection)));
+            setLoading(false);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setCollections(null);
+            setLoading(false);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (galleries.length > 0) {
+            const { assetArray, collectionsArray } = getMediaForGallery(galleries, true);
+            if (assetArray.length > 0) {
+                fetchAssets({ variables: { assetIds: assetArray } });
+            }
+            if (collectionsArray.length > 0) {
+                fetchCollections({ variables: { collectionIds: collectionsArray } });
+            }
+        }
+    }, [galleries, fetchAssets, fetchCollections]);
+    async function refetchQueryGalleriesList() {
+        await refetch();
+    }
+    async function loadMoreGalleriesList() {
+        if (!nextPageToken.current || !isHaveNextPage || galleries.length >= maxUserFavoritesLength)
+            return;
+        setIsNextLoading(true);
+        await fetchMore({
+            variables: { pageToken: nextPageToken.current },
+            updateQuery: (prev, { fetchMoreResult }) => {
+                if (!fetchMoreResult)
+                    return prev;
+                const { nextPageToken: token, galleries: nextGalleries } = fetchMoreResult.fetchMyFavoritesV2;
+                nextPageToken.current = token || null;
+                if (prev !== null && prev.hasOwnProperty("fetchMyGalleriesV2")) {
+                    const { galleries: prevGalleries } = prev.fetchMyGalleriesV2;
+                    return {
+                        fetchMyGalleriesV2: {
+                            galleries: [...prevGalleries, ...nextGalleries],
+                            nextPageToken: token,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        fetchMyGalleriesV2: {
+                            galleries: nextGalleries,
+                            nextPageToken: token,
+                        },
+                    };
+                }
+            },
+        });
+    }
+    return {
+        galleries,
+        assets,
+        collections,
+        loading,
+        loadingAssets: assetsLoading,
+        loadingFavorites: favoritesLoading,
+        loadingCollections: collectionsLoading,
+        errorAssets: assetsError,
+        errorCollections: collectionsError,
+        errorGalleries: galleriesError,
+        refetchQueryGalleriesList,
+        loadMoreGalleriesList,
+        isNextLoading,
+    };
+};
+exports.useGetUserGalleriesCreations = useGetUserGalleriesCreations;
+function getMediaForGallery(favorites, takeFirstFour) {
+    if (favorites.length === 0)
+        return { assetArray: [], collectionsArray: [] };
+    const assetArray = [];
+    const collectionsArray = [];
+    favorites.forEach((fav) => {
+        const creationIds = takeFirstFour ? fav.creationIds.slice(0, 4) : fav.creationIds;
+        if (!creationIds || creationIds.length === 0)
+            return;
+        for (let i = 0; i < creationIds.length; i++) {
+            if (creationIds[i].split(".")[0] === "asset") {
+                const assetId = creationIds[i].split(".").splice(1, creationIds[i].length).join(".");
+                assetArray.push(assetId);
+            }
+            else if (creationIds[i].split(".")[0] === "collection") {
+                const collectionId = creationIds[i].split(".").splice(1, creationIds[i].length).join(".");
+                collectionsArray.push(collectionId);
+            }
+        }
+    });
+    return { assetArray, collectionsArray };
+}

package/build/hooks/likes/dynamic/useFindCollectionsAndLikes.d.ts

@@ -0,0 +1,29 @@
+import { TCreation } from '../../../entities/creation/types';
+import { IDynamicCollectionData, IQueryFindCollectionsArgs } from "@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema";
+export declare const useFindCollectionsAndLikes: ({ term, input, page }: IQueryFindCollectionsArgs) => {
+    loadMore: (pageToken: string) => Promise<void>;
+    loading: boolean;
+    collectionsLoading: boolean;
+    collectionsLikesLoading: boolean;
+    collectionsLikes: [] | IDynamicCollectionData[];
+    error: import("@apollo/client").ApolloError | undefined;
+    results: number;
+    collections: TCreation[];
+    nextPageToken: string | null;
+    refetchQuery: () => Promise<void>;
+};
+declare const _default: {
+    useFindCollectionsAndLikes: ({ term, input, page }: IQueryFindCollectionsArgs) => {
+        loadMore: (pageToken: string) => Promise<void>;
+        loading: boolean;
+        collectionsLoading: boolean;
+        collectionsLikesLoading: boolean;
+        collectionsLikes: [] | IDynamicCollectionData[];
+        error: import("@apollo/client").ApolloError | undefined;
+        results: number;
+        collections: TCreation[];
+        nextPageToken: string | null;
+        refetchQuery: () => Promise<void>;
+    };
+};
+export default _default;

package/build/hooks/likes/dynamic/useFindCollectionsAndLikes.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFindCollectionsAndLikes = void 0;
+const collectionCreationBuilder_1 = require("../../../entities/creation/collectionCreationBuilder");
+const types_1 = require("../../../entities/labelCreationType/types");
+const useGetCreationsAndLikes_1 = require("./useGetCreationsAndLikes");
+const ui_1 = require("../../../store/ui");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const schema_1 = require("@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema");
+const react_1 = require("react");
+const getErrorAlertProps_1 = require("../../../utils/getErrorAlertProps");
+// export const prefetchFindCollections = (
+//   { term, input, pageSize, pageToken }: schema.IQueryFindCollectionsArgs,
+//   apolloClient: ApolloClient<NormalizedCacheObject>
+// ) => {
+//   return apolloClient
+//     .query({
+//       query: schema.FindCollectionsDocument,
+//       variables: { term, input, pageSize, pageToken },
+//       context: { uri: hosts.serverSearchHost },
+//       fetchPolicy: 'network-only',
+//     })
+//     .catch(() => {
+//       return {
+//         data: { findCollections: null },
+//       };
+//     });
+// };
+const maxCollectionsLength = 1000;
+const useFindCollectionsAndLikes = ({ term, input, page }) => {
+    const [collections, setCollections] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [collectionsLikes, setCollectionsLikes] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const { error, loading: collectionsLoading, fetchMore, refetch, } = (0, schema_1.useFindCollectionsQuery)({
+        fetchPolicy: "no-cache",
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        variables: {
+            term,
+            input,
+            page,
+        },
+        onCompleted: ({ findCollections: { collections, ...nextPage } }) => {
+            setCollections(collections.map((collection) => (0, collectionCreationBuilder_1.buildCollectionCreation)({
+                ...collection,
+                name: collection && collection.collectionTitle,
+            }, types_1.LabelKeys.collection)));
+            if (!collections.length) {
+                setLoading(false);
+            }
+            setResults(nextPage.nextPage?.elements || 0);
+            setNextPageToken(nextPage.nextPage?.token || null);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setCollections([]);
+            setNextPageToken(null);
+        },
+    });
+    const [fetchCollectionsLikes, { loading: collectionsLikesLoading }] = (0, client_1.useLazyQuery)(schema_1.FetchDynamicCollectionsDataDocument, {
+        context: { uri: api_1.hosts.searchHost },
+        onCompleted: ({ fetchDynamicCollectionsData }) => {
+            setCollectionsLikes(fetchDynamicCollectionsData);
+            setLoading(false);
+        },
+        fetchPolicy: "no-cache",
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setCollectionsLikes([]);
+            setLoading(false);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (collections.length > 0) {
+            const itemsIdsArray = (0, useGetCreationsAndLikes_1.extractItemIds)(collections);
+            if (itemsIdsArray.length > 0) {
+                if (collections[0].itemType === types_1.LabelKeys.collection) {
+                    fetchCollectionsLikes({
+                        variables: {
+                            input: itemsIdsArray.map((collectionId) => {
+                                return {
+                                    collectionId,
+                                };
+                            }),
+                        },
+                    });
+                }
+            }
+        }
+    }, [collections, fetchCollectionsLikes]);
+    (0, react_1.useEffect)(() => {
+        setLoading(true);
+        setCollectionsLikes([]);
+        setCollections([]);
+    }, [term, input]);
+    return {
+        loadMore,
+        loading,
+        collectionsLoading,
+        collectionsLikesLoading,
+        collectionsLikes,
+        error,
+        results,
+        collections,
+        nextPageToken,
+        refetchQuery,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || collections.length >= maxCollectionsLength)
+            return;
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    term,
+                    input,
+                    page,
+                },
+                updateQuery: (previousQueryResult) => {
+                    return previousQueryResult;
+                },
+            });
+            const { collections: nextCollections, ...nextPage } = data.findCollections;
+            const nextList = nextCollections.map((collectionAsset) => (0, collectionCreationBuilder_1.buildCollectionCreation)({
+                ...collectionAsset,
+                name: collectionAsset && collectionAsset.collectionTitle,
+            }, types_1.LabelKeys.collection));
+            setCollections((prevCollection) => [...prevCollection, ...nextList]);
+            setResults(nextPage.nextPage?.elements || 0);
+            setNextPageToken(nextPage.nextPage?.token || null);
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    }
+};
+exports.useFindCollectionsAndLikes = useFindCollectionsAndLikes;
+exports.default = { /*prefetchFindCollections,*/ useFindCollectionsAndLikes: /*prefetchFindCollections,*/ exports.useFindCollectionsAndLikes };

package/build/hooks/likes/dynamic/useFindCreationsAndLikes.d.ts

@@ -0,0 +1,15 @@
+import { TCreation } from '../../../entities/creation/types';
+import { IDynamicAssetData, IQueryFindCreationsArgs } from "@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema";
+declare const useFindCreationsAndLikes: ({ term, input, page }: IQueryFindCreationsArgs) => {
+    loading: boolean;
+    assetsLikesLoading: boolean;
+    creationsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    creations: TCreation[];
+    results: number;
+    assetsLikes: [] | IDynamicAssetData[];
+    nextPageToken: string | null;
+    loadMore: (pageToken: string | null) => Promise<void>;
+    refetchQuery: () => Promise<void>;
+};
+export { useFindCreationsAndLikes };

package/build/hooks/likes/dynamic/useFindCreationsAndLikes.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFindCreationsAndLikes = void 0;
+const builder_1 = require("../../../entities/creation/builder");
+const useGetCreationsAndLikes_1 = require("./useGetCreationsAndLikes");
+const ui_1 = require("../../../store/ui");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const schema_1 = require("@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema");
+const react_1 = require("react");
+const getErrorAlertProps_1 = require("../../../utils/getErrorAlertProps");
+const maxCreationLength = 1000;
+const useFindCreationsAndLikes = ({ term, input, page }) => {
+    const [creations, setCreations] = (0, react_1.useState)([]);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [assetsLikes, setAssetsLikes] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { error: creationsError, loading: creationsLoading, refetch, fetchMore, } = (0, schema_1.useFindCreationsQuery)({
+        variables: {
+            term,
+            input,
+            page,
+        },
+        fetchPolicy: "no-cache",
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        onCompleted: ({ findCreations: { creations, ...nextPage } }) => {
+            setCreations(creations.map((creation) => (0, builder_1.buildCreation)(creation)));
+            if (!creations.length) {
+                setLoading(false);
+            }
+            setResults(nextPage.nextPage?.elements || 0);
+            setNextPageToken(nextPage.nextPage?.token || null);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setCreations([]);
+            setNextPageToken(null);
+            setLoading(false);
+            setResults(0);
+        },
+    });
+    const [fetchAssetsLikes, { loading: assetsLikesLoading }] = (0, client_1.useLazyQuery)(schema_1.FetchDynamicAssetsLikesDocument, {
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchDynamicAssetsData }) => {
+            setAssetsLikes(fetchDynamicAssetsData);
+            setLoading(false);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setAssetsLikes([]);
+            setLoading(false);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (creations.length > 0) {
+            const itemsIdsArray = (0, useGetCreationsAndLikes_1.extractItemIds)(creations);
+            if (itemsIdsArray.length > 0) {
+                fetchAssetsLikes({ variables: { assetIds: itemsIdsArray } });
+            }
+        }
+    }, [creations, fetchAssetsLikes]);
+    (0, react_1.useEffect)(() => {
+        setLoading(true);
+        setAssetsLikes([]);
+        setCreations([]);
+    }, [term, input]);
+    return {
+        loading,
+        assetsLikesLoading,
+        creationsLoading,
+        error: creationsError,
+        creations,
+        results,
+        assetsLikes,
+        nextPageToken,
+        loadMore,
+        refetchQuery,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || creations.length >= maxCreationLength)
+            return;
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    term,
+                    input,
+                    page: {
+                        token: pageToken,
+                        ...(page && "size" in page ? { size: page.size } : {}),
+                    },
+                },
+                updateQuery: (previousQueryResult) => {
+                    return previousQueryResult;
+                },
+            });
+            const { creations: nextCreations, ...nextPage } = data.findCreations;
+            setCreations((prevCreations) => [
+                ...prevCreations,
+                ...nextCreations.map((creation) => (0, builder_1.buildCreation)(creation)),
+            ]);
+            setResults(nextPage.nextPage?.elements || 0);
+            setNextPageToken(nextPage.nextPage?.token || null);
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useFindCreationsAndLikes = useFindCreationsAndLikes;

package/build/hooks/likes/dynamic/useGetCollectionInfoAndLikes.d.ts

@@ -0,0 +1,14 @@
+import { TCreation } from '../../../entities/creation/types';
+import { IDynamicAssetData, IQueryFetchDynamicCollectionDataArgs } from "@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema";
+declare const useGetCollectionInfoAndLikes: ({ input }: IQueryFetchDynamicCollectionDataArgs) => {
+    collectionAssetsList: TCreation[];
+    collectionItemsLikes: [] | IDynamicAssetData[];
+    collectionLikes: number;
+    isCollectionLikedByUser: boolean;
+    nextPageToken: string | null;
+    loading: boolean;
+    loadMore: (pageToken: string | null) => Promise<void>;
+    refetchQuery: () => Promise<void>;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export { useGetCollectionInfoAndLikes };

package/build/hooks/likes/dynamic/useGetCollectionInfoAndLikes.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetCollectionInfoAndLikes = void 0;
+const collectionCreationBuilder_1 = require("../../../entities/creation/collectionCreationBuilder");
+const useGetCreationsAndLikes_1 = require("./useGetCreationsAndLikes");
+const ui_1 = require("../../../store/ui");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const schema_1 = require("@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema");
+const react_1 = require("react");
+const getErrorAlertProps_1 = require("../../../utils/getErrorAlertProps");
+const maxCollectionListLength = 1000;
+const useGetCollectionInfoAndLikes = ({ input }) => {
+    const { page, collectionId } = input;
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [collectionAssetsList, setCollectionAssetsList] = (0, react_1.useState)([]);
+    const [collectionItemsLikes] = (0, react_1.useState)([]);
+    const [collectionLikes, setCollectionLikes] = (0, react_1.useState)(0);
+    const [isCollectionLikedByUser, setIsCollectionLikedByUser] = (0, react_1.useState)(false);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const { error, loading: collectionLoading, fetchMore, refetch, } = (0, client_1.useQuery)(schema_1.FetchDynamicCollectionDataDocument, {
+        variables: { input },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        // fetchPolicy: 'cache-first',
+        onCompleted: ({ fetchDynamicCollectionData: { isLikedByUser, likesNum, collectionAssetsPage: { nextPage, collectionAssets }, }, }) => {
+            setCollectionLikes(likesNum);
+            setIsCollectionLikedByUser(isLikedByUser);
+            setNextPageToken(nextPage.token);
+            setCollectionAssetsList(collectionAssets.map((collectionAsset) => (0, collectionCreationBuilder_1.buildCollectionCreation)({
+                ...collectionAsset,
+                collectionId: collectionAsset.assetId,
+            })));
+            setLoading(false);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setCollectionAssetsList([]);
+            setNextPageToken(null);
+            setLoading(false);
+        },
+    });
+    // const [fetchAssetsLikes, {}] = useLazyQuery(
+    //   schema.FetchDynamicAssetsLikesDocument,
+    //   {
+    //     context: {
+    //       uri: hosts.searchHost,
+    //     },
+    //     fetchPolicy: 'no-cache',
+    //     onCompleted: ({ fetchDynamicAssetsData }) => {
+    //       setCollectionItemsLikes((prev) => [...prev, ...fetchDynamicAssetsData]);
+    //       setLoading(false);
+    //     },
+    //     onError: (err) => {
+    //       openAlert({
+    //         ...alertError,
+    //         caption: 'Oops, something went wrong.',
+    //       });
+    //       console.error(err);
+    //       setCollectionItemsLikes([]);
+    //       setLoading(false);
+    //     },
+    //   }
+    // );
+    (0, react_1.useEffect)(() => {
+        if (!collectionLoading && collectionAssetsList.length > 0) {
+            const assetIds = (0, useGetCreationsAndLikes_1.extractItemIds)(collectionAssetsList);
+            if (assetIds.length > 0 && collectionAssetsList.length !== collectionItemsLikes.length) {
+                setLoading(false);
+                {
+                    /* Todo fix it by PR with new likes  */
+                }
+                // fetchAssetsLikes({ variables: { assetIds } });
+            }
+        }
+    }, [
+        collectionAssetsList,
+        collectionLoading,
+        collectionItemsLikes,
+        // fetchAssetsLikes,
+    ]);
+    return {
+        collectionAssetsList,
+        collectionItemsLikes,
+        collectionLikes,
+        isCollectionLikedByUser,
+        nextPageToken,
+        loading,
+        loadMore,
+        refetchQuery,
+        error,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || collectionAssetsList.length >= maxCollectionListLength)
+            return;
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    input: { page: { token: pageToken, size: page?.size }, collectionId },
+                },
+            });
+            const { collectionAssetsPage: { nextPageToken, collectionAssets: nextCollectionAssetsList }, } = data.fetchDynamicCollectionData;
+            const nextList = nextCollectionAssetsList.map((collectionAsset) => (0, collectionCreationBuilder_1.buildCollectionCreation)({
+                ...collectionAsset,
+                collectionId: collectionAsset.assetId,
+            }));
+            // const assetIds = getAssetIds(nextList);
+            // await fetchAssetsLikes({ variables: { assetIds } });
+            setCollectionAssetsList((prevCollection) => [...prevCollection, ...nextList]);
+            setNextPageToken(nextPageToken);
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    }
+    // function getAssetIds(collection: CollectionCreationEntity[]) {
+    //   return collection.map((item) => item.getItemId());
+    // }
+};
+exports.useGetCollectionInfoAndLikes = useGetCollectionInfoAndLikes;

package/build/hooks/likes/dynamic/useGetCreationsAndLikes.d.ts

@@ -0,0 +1,17 @@
+import { TCreation } from '../../../entities/creation/types';
+import { IDynamicAssetData, IDynamicCollectionData, IQueryFetchAllCreationsArgs } from "@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema";
+declare const useGetCreationsAndLikes: ({ page }: IQueryFetchAllCreationsArgs) => {
+    loading: boolean;
+    assetsLikesLoading: boolean;
+    collectionsLikesLoading: boolean;
+    creationsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    allCreations: TCreation[];
+    assetsLikes: [] | IDynamicAssetData[];
+    collectionsLikes: [] | IDynamicCollectionData[];
+    nextPageToken: string | null;
+    loadMore: (pageToken: string | null) => Promise<void>;
+    refetchQuery: () => Promise<void>;
+};
+declare function extractItemIds(creations: TCreation[]): string[];
+export { useGetCreationsAndLikes, extractItemIds };