@ludo.ninja/components 2.3.6 → 2.3.8

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetCreationsAndLikes = void 0;
+exports.extractItemIds = extractItemIds;
+const builder_1 = require("../../../entities/creation/builder");
+const types_1 = require("../../../entities/labelCreationType/types");
+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 type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const react_1 = require("react");
+const maxCreationLength = 1000;
+const useGetCreationsAndLikes = ({ page }) => {
+    const [allCreations, setCreations] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [assetsLikes, setAssetsLikes] = (0, react_1.useState)([]);
+    const [collectionsLikes, setCollectionsLikes] = (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.useFetchAllCreationsQuery)({
+        variables: {
+            page,
+        },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        onCompleted: ({ fetchAllCreations: { creations, ...nextPage } }) => {
+            setCreations(creations.map((creation) => (0, builder_1.buildCreation)(creation)));
+            setNextPageToken(nextPage.nextPage?.token || null);
+        },
+        onError: () => {
+            setCreations([]);
+            setNextPageToken(null);
+            setLoading(false);
+        },
+    });
+    const [fetchAssetsLikes, { loading: assetsLikesLoading }] = (0, client_1.useLazyQuery)(schema_1.FetchDynamicAssetsLikesDocument, {
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        onCompleted: ({ fetchDynamicAssetsData }) => {
+            setAssetsLikes(fetchDynamicAssetsData);
+            setLoading(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong when fetch assets likes.",
+            });
+            setAssetsLikes([]);
+            setLoading(false);
+        },
+    });
+    const [fetchCollectionsLikes, { loading: collectionsLikesLoading }] = (0, client_1.useLazyQuery)(schema_1.FetchDynamicCollectionsDataDocument, {
+        context: { uri: api_1.hosts.searchHost },
+        onCompleted: ({ fetchDynamicCollectionsData }) => {
+            setCollectionsLikes(fetchDynamicCollectionsData);
+            setLoading(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong when fetch collections likes.",
+            });
+            setCollectionsLikes([]);
+            setLoading(false);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (allCreations.length > 0) {
+            const itemsIdsArray = extractItemIds(allCreations);
+            if (itemsIdsArray.length > 0) {
+                if (allCreations[0].itemType === types_1.LabelKeys.asset) {
+                    fetchAssetsLikes({ variables: { assetIds: itemsIdsArray } });
+                }
+                else if (allCreations[0].itemType === types_1.LabelKeys.collection) {
+                    fetchCollectionsLikes({
+                        variables: {
+                            input: itemsIdsArray.map((collectionId) => {
+                                return {
+                                    collectionId,
+                                };
+                            }),
+                        },
+                    });
+                }
+            }
+        }
+    }, [allCreations, fetchAssetsLikes, fetchCollectionsLikes]);
+    return {
+        loading,
+        assetsLikesLoading,
+        collectionsLikesLoading,
+        creationsLoading,
+        error: creationsError,
+        allCreations,
+        assetsLikes,
+        collectionsLikes,
+        nextPageToken,
+        loadMore,
+        refetchQuery,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || allCreations.length >= maxCreationLength)
+            return;
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    page: {
+                        token: pageToken,
+                        ...(page && "size" in page ? { size: page.size } : {}),
+                    },
+                },
+            });
+            const { creations: nextCreations, ...nextPage } = data.fetchAllCreations;
+            setCreations((prevCreations) => [
+                ...prevCreations,
+                ...nextCreations.map((creation) => (0, builder_1.buildCreation)(creation)),
+            ]);
+            setNextPageToken(nextPage.nextPage?.token || null);
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useGetCreationsAndLikes = useGetCreationsAndLikes;
+function extractItemIds(creations) {
+    return creations.map((creation) => creation.itemId);
+}

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

@@ -0,0 +1,16 @@
+import { TCreation } from '../../../entities/creation/types';
+import { IDynamicAssetData, IDynamicCollectionData, IQueryFetchCreationsByTypeArgs } from "@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema";
+declare const useGetCreationsAndLikesByType: ({ itemType, page }: IQueryFetchCreationsByTypeArgs) => {
+    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>;
+};
+export { useGetCreationsAndLikesByType };

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetCreationsAndLikesByType = void 0;
+const useGetCreationsAndLikes_1 = require("./useGetCreationsAndLikes");
+const builder_1 = require("../../../entities/creation/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__/searchHost/schema");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const react_1 = require("react");
+const maxCreationLength = 1000;
+const useGetCreationsAndLikesByType = ({ itemType, page }) => {
+    const [allCreations, setAllCreations] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [assetsLikes, setAssetsLikes] = (0, react_1.useState)([]);
+    const [collectionsLikes, setCollectionsLikes] = (0, react_1.useState)([]);
+    const [currentItemType, setCurrentItemType] = (0, react_1.useState)(itemType);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { error: creationsError, loading: creationsLoading, fetchMore, refetch, } = (0, schema_1.useFetchCreationsByTypeQuery)({
+        variables: {
+            itemType,
+            page,
+        },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchCreationsByType: { creations, ...data } }) => {
+            setAllCreations(creations.map((creation) => (0, builder_1.buildCreation)(creation)));
+            setNextPageToken(data.nextPage?.token || null);
+            setLoading(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+            });
+            setAllCreations([]);
+            setNextPageToken(null);
+            setLoading(false);
+        },
+    });
+    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: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong when fetch assets likes.",
+            });
+            setAssetsLikes([]);
+            setLoading(false);
+        },
+    });
+    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: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something wrong with collections likes.",
+            });
+            setCollectionsLikes([]);
+            setLoading(false);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (allCreations.length > 0) {
+            const itemsIdsArray = (0, useGetCreationsAndLikes_1.extractItemIds)(allCreations);
+            if (itemsIdsArray.length > 0) {
+                if (currentItemType === "asset") {
+                    fetchAssetsLikes({ variables: { assetIds: itemsIdsArray } });
+                }
+                else if (currentItemType === "collection") {
+                    fetchCollectionsLikes({
+                        variables: {
+                            input: itemsIdsArray.map((collectionId) => {
+                                return {
+                                    collectionId,
+                                };
+                            }),
+                        },
+                    });
+                }
+            }
+        }
+    }, [allCreations, fetchAssetsLikes, fetchCollectionsLikes, currentItemType]);
+    (0, react_1.useEffect)(() => {
+        setLoading(true);
+        setCurrentItemType(itemType);
+        setAssetsLikes([]);
+        setCollectionsLikes([]);
+        setAllCreations([]);
+    }, [itemType]);
+    return {
+        loading,
+        assetsLikesLoading,
+        collectionsLikesLoading,
+        creationsLoading,
+        error: creationsError,
+        allCreations,
+        assetsLikes,
+        collectionsLikes,
+        nextPageToken,
+        loadMore,
+        refetchQuery,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || allCreations.length >= maxCreationLength)
+            return;
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    itemType,
+                    page: {
+                        token: pageToken,
+                        ...(page && "size" in page ? { size: page.size } : {}),
+                    },
+                },
+                updateQuery: (previousQueryResult) => {
+                    return previousQueryResult;
+                },
+            });
+            const { creations: nextCreations, ...token } = data.fetchCreationsByType;
+            setAllCreations((prevCreations) => [
+                ...prevCreations,
+                ...nextCreations.map((creation) => (0, builder_1.buildCreation)(creation)),
+            ]);
+            setNextPageToken(token.nextPage?.token || null);
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useGetCreationsAndLikesByType = useGetCreationsAndLikesByType;

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

@@ -0,0 +1,18 @@
+import { TCreation } from '../../../entities/creation/types';
+import { searchSchema as schema } from "@ludo.ninja/api";
+declare const useGetMixedLikesFavoriteList: ({ galleryId, itemsCount }: {
+    galleryId: string;
+    itemsCount: number | null;
+}) => {
+    gallery: import("../../../entities/gallery/types").TGallery[] | null;
+    creationsList: TCreation[];
+    likes: (schema.IDynamicAssetData | schema.IDynamicCollectionData)[];
+    allResults: number | null;
+    loading: boolean;
+    errorAssets: import("@apollo/client").ApolloError | undefined;
+    errorCollections: import("@apollo/client").ApolloError | undefined;
+    errorGallery: import("@apollo/client").ApolloError | undefined;
+    allItemsFetched: boolean;
+    loadMore: () => void;
+};
+export default useGetMixedLikesFavoriteList;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const useGetTableLikes_1 = require("./useGetTableLikes");
+const types_1 = require("../../../entities/labelCreationType/types");
+const useGetFavoriteGallaryCreations_1 = require("../../favorites/useGetFavoriteGallaryCreations");
+const react_1 = require("react");
+const useGetMixedLikesFavoriteList = ({ galleryId, itemsCount }) => {
+    const [likes, setLikes] = (0, react_1.useState)([]);
+    const [creationsList, setCreationsList] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [allItemsFetched, setAllItemsFetched] = (0, react_1.useState)(false);
+    const { gallery, creationsList: fetchedCreationsList, loading: creationsLoading, allResults, errorAssets, errorCollections, errorGallery, loadMore, } = (0, useGetFavoriteGallaryCreations_1.useGetFavoriteGallaryCreations)({ galleryId, itemsCount });
+    const { assetsLikes, collectionsLikes, loadingLikes } = (0, useGetTableLikes_1.useGetTableLikes)({
+        allItems: fetchedCreationsList,
+    });
+    // TODO resolve JSON.stringify
+    (0, react_1.useEffect)(() => {
+        if (!creationsLoading && !loadingLikes) {
+            const combinedLikes = [];
+            fetchedCreationsList.forEach((item) => {
+                if (item.itemType === types_1.LabelKeys.asset) {
+                    combinedLikes.push(...assetsLikes.filter((like) => like.assetId === item.itemId));
+                }
+                else {
+                    combinedLikes.push(...collectionsLikes.filter((like) => like.collectionId === item.creationId));
+                }
+            });
+            creationsList.length !== combinedLikes.length &&
+                setLikes(combinedLikes);
+            creationsList.length !== combinedLikes.length && setCreationsList(fetchedCreationsList);
+            fetchedCreationsList.length === combinedLikes.length && setLoading(false);
+            creationsList.length === fetchedCreationsList.length && setAllItemsFetched(true);
+        }
+    }, [creationsLoading, JSON.stringify(fetchedCreationsList), loadingLikes]);
+    return {
+        gallery,
+        creationsList,
+        likes,
+        allResults,
+        loading,
+        errorAssets,
+        errorCollections,
+        errorGallery,
+        allItemsFetched,
+        loadMore,
+    };
+};
+exports.default = useGetMixedLikesFavoriteList;

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

@@ -0,0 +1,14 @@
+import { TCreation } from '../../../entities/creation/types';
+import { searchSchema as schema } from "@ludo.ninja/api";
+declare const useGetTableLikes: ({ allItems }: {
+    allItems: Array<TCreation>;
+}) => {
+    fetchAssetsLikes: import("@apollo/client").LazyQueryExecFunction<any, import("@apollo/client").OperationVariables>;
+    fetchCollectionsLikes: import("@apollo/client").LazyQueryExecFunction<any, import("@apollo/client").OperationVariables>;
+    assetsLikes: [] | schema.IDynamicAssetData[];
+    collectionsLikes: [] | schema.IDynamicCollectionData[];
+    loadingLikes: boolean;
+    errorAssets: import("@apollo/client").ApolloError | undefined;
+    errorCollections: import("@apollo/client").ApolloError | undefined;
+};
+export { useGetTableLikes };

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetTableLikes = void 0;
+const types_1 = require("../../../entities/labelCreationType/types");
+const ui_1 = require("../../../store/ui");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const react_1 = require("react");
+const useGetTableLikes = ({ allItems }) => {
+    const [assetsLikes, setAssetsLikes] = (0, react_1.useState)([]);
+    const [collectionsLikes, setCollectionsLikes] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const prevAssetsIds = (0, react_1.useRef)([]);
+    const prevCollectionsIds = (0, react_1.useRef)([]);
+    const activeRequestsCount = (0, react_1.useRef)(0);
+    const [fetchAssetsLikes, { error: assetsError,
+    // loading: assetsLoading,
+     },] = (0, client_1.useLazyQuery)(api_1.searchSchema.FetchDynamicAssetsLikesDocument, {
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchDynamicAssetsData }) => {
+            setAssetsLikes(fetchDynamicAssetsData);
+            activeRequestsCount.current -= 1;
+            checkAllRequestsCompleted();
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+            });
+            setAssetsLikes([]);
+            activeRequestsCount.current -= 1;
+            checkAllRequestsCompleted();
+        },
+    });
+    const [fetchCollectionsLikes, { error: collectionsError,
+    // loading: collectionsLoading
+     },] = (0, client_1.useLazyQuery)(api_1.searchSchema.FetchDynamicCollectionsDataDocument, {
+        context: { uri: api_1.hosts.searchHost },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchDynamicCollectionsData }) => {
+            setCollectionsLikes(fetchDynamicCollectionsData);
+            activeRequestsCount.current -= 1;
+            checkAllRequestsCompleted();
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+            });
+            setCollectionsLikes([]);
+            activeRequestsCount.current -= 1;
+            checkAllRequestsCompleted();
+        },
+    });
+    const checkAllRequestsCompleted = () => {
+        if (activeRequestsCount.current === 0) {
+            setLoading(false);
+        }
+    };
+    (0, react_1.useEffect)(() => {
+        if (allItems && allItems.length > 0) {
+            const assetIds = [];
+            const collectionIds = [];
+            allItems.forEach((item) => {
+                if (item.itemType === types_1.LabelKeys.asset) {
+                    assetIds.push(item.itemId);
+                }
+                else if (item.itemType === types_1.LabelKeys.collection) {
+                    collectionIds.push(item.creationId);
+                }
+            });
+            if (assetIds.length > 0 && JSON.stringify(assetIds) !== JSON.stringify(prevAssetsIds.current)) {
+                prevAssetsIds.current = assetIds;
+                activeRequestsCount.current += 1;
+                !loading && setLoading(true);
+                fetchAssetsLikes({ variables: { assetIds } });
+            }
+            if (collectionIds.length > 0 && JSON.stringify(collectionIds) !== JSON.stringify(prevCollectionsIds.current)) {
+                prevCollectionsIds.current = collectionIds;
+                activeRequestsCount.current += 1;
+                !loading && setLoading(true);
+                fetchCollectionsLikes({
+                    variables: {
+                        input: collectionIds.map((collectionId) => {
+                            return {
+                                collectionId,
+                            };
+                        }),
+                    },
+                });
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [allItems, fetchAssetsLikes, fetchCollectionsLikes]);
+    return {
+        fetchAssetsLikes,
+        fetchCollectionsLikes,
+        assetsLikes,
+        collectionsLikes,
+        loadingLikes: loading,
+        errorAssets: assetsError,
+        errorCollections: collectionsError,
+    };
+};
+exports.useGetTableLikes = useGetTableLikes;

package/build/hooks/likes/index.d.ts

@@ -0,0 +1,19 @@
+import { LabelKeys } from '../../entities/labelCreationType/types';
+import { RemoveToolsType } from '../../system/Cards/CreationCard';
+export type LikesType = {
+    likesCount: number;
+    isLiked: boolean;
+};
+declare const useLikes: ({ defaultLikesCount, defaultIsLiked, itemType, removeOnDislike, isLoadingLikes, }: {
+    defaultLikesCount: number;
+    defaultIsLiked: boolean;
+    itemType: LabelKeys;
+    removeOnDislike?: RemoveToolsType | undefined;
+    isLoadingLikes?: boolean | undefined;
+}) => {
+    likes: LikesType;
+    addLike: (id: string) => Promise<void>;
+    deleteLike: (id: string) => Promise<void>;
+    isLoading: boolean;
+};
+export default useLikes;

package/build/hooks/likes/index.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const useDislikeAsset_1 = __importDefault(require("../../api/server-assets/mutations/useDislikeAsset"));
+const useLikeAsset_1 = __importDefault(require("../../api/server-assets/mutations/useLikeAsset"));
+const useDislikeCollection_1 = __importDefault(require("../../api/server-collection/mutations/useDislikeCollection"));
+const useLikeCollection_1 = __importDefault(require("../../api/server-collection/mutations/useLikeCollection"));
+const useRemoveAssetFromGallery_1 = require("../../api/server-galleries/mutations/useRemoveAssetFromGallery");
+const useRemoveCollectionFromGallery_1 = require("../../api/server-galleries/mutations/useRemoveCollectionFromGallery");
+const types_1 = require("../../entities/labelCreationType/types");
+const ui_1 = require("../../store/ui");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const react_1 = require("react");
+// Component
+const useLikes = ({ defaultLikesCount, defaultIsLiked, itemType, removeOnDislike, isLoadingLikes, }) => {
+    const [likes, setLikes] = (0, react_1.useState)({
+        likesCount: defaultLikesCount,
+        isLiked: defaultIsLiked,
+    });
+    (0, react_1.useEffect)(() => {
+        if (!isLoadingLikes) {
+            setLikes({
+                likesCount: defaultLikesCount,
+                isLiked: defaultIsLiked,
+            });
+        }
+    }, [isLoadingLikes]);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const { likeAsset, errorLikeAsset } = (0, useLikeAsset_1.default)();
+    const { dislikeAsset, errorDislikeAsset } = (0, useDislikeAsset_1.default)();
+    const { dislikeCollection, errorDislikeCollection } = (0, useDislikeCollection_1.default)();
+    const { likeCollection, errorLikeCollection } = (0, useLikeCollection_1.default)();
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { removeAssetFromGallery, errorRemoveAsset } = (0, useRemoveAssetFromGallery_1.useRemoveAssetFromGalleryV2)();
+    const { removeCollectionFromGallery, errorRemoveCollection } = (0, useRemoveCollectionFromGallery_1.useRemoveCollectionFromGalleryV2)();
+    (0, react_1.useEffect)(() => {
+        if (errorLikeAsset ||
+            errorDislikeAsset ||
+            errorDislikeCollection ||
+            errorLikeCollection ||
+            errorRemoveAsset ||
+            errorRemoveCollection) {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+                text: "Please try another NFT",
+            });
+            setLikes({
+                likesCount: defaultLikesCount,
+                isLiked: false,
+            });
+            setIsLoading(false);
+        }
+    }, [
+        errorLikeAsset,
+        errorDislikeAsset,
+        errorDislikeCollection,
+        errorLikeCollection,
+        errorRemoveAsset,
+        errorRemoveCollection,
+    ]);
+    const addLike = async (id) => {
+        setIsLoading(true);
+        if (itemType === types_1.LabelKeys.asset) {
+            await likeAsset({ assetId: id });
+        }
+        else if (itemType === types_1.LabelKeys.collection) {
+            await likeCollection({ collectionId: id });
+        }
+        if (!errorLikeAsset || !errorLikeCollection) {
+            setLikes({
+                likesCount: likes.likesCount + 1,
+                isLiked: true,
+            });
+        }
+        setIsLoading(false);
+    };
+    const deleteLike = async (id) => {
+        setIsLoading(true);
+        if (itemType === types_1.LabelKeys.asset) {
+            await dislikeAsset({ assetId: id });
+            if (removeOnDislike && removeOnDislike.gallery) {
+                await removeAssetFromGallery({
+                    galleryId: removeOnDislike.gallery.galleryId,
+                    assetId: id,
+                });
+                removeOnDislike?.removeFn(itemType);
+            }
+        }
+        else if (itemType === types_1.LabelKeys.collection) {
+            await dislikeCollection({ collectionId: id });
+            if (removeOnDislike && removeOnDislike.gallery) {
+                await removeCollectionFromGallery({
+                    galleryId: removeOnDislike.gallery.galleryId,
+                    collectionId: id,
+                });
+                removeOnDislike?.removeFn(itemType);
+            }
+        }
+        if (!errorDislikeAsset || !errorDislikeCollection) {
+            setLikes({
+                likesCount: likes.likesCount - 1,
+                isLiked: false,
+            });
+        }
+        setIsLoading(false);
+    };
+    return { likes, addLike, deleteLike, isLoading };
+};
+// Export
+exports.default = useLikes;

package/build/hooks/likes/useGetLikesAsset.d.ts

@@ -0,0 +1,20 @@
+import { searchSchema } from '@ludo.ninja/api';
+export type TCurrentItemType = 'asset' | 'collection';
+export declare const useGetLikesAsset: () => {
+    isLoadingLikes: boolean;
+    fetchLikes: (itemsIdsArray: string[], currentItemType: TCurrentItemType) => Promise<void>;
+    likes: Map<string, {
+        assetId: searchSchema.Scalars["String"];
+        isLikedByUser?: searchSchema.Maybe<searchSchema.Scalars["Boolean"]>;
+        likesNum?: searchSchema.Maybe<searchSchema.Scalars["Int"]>;
+        medias?: searchSchema.Maybe<Array<searchSchema.Maybe<searchSchema.IMedia>>>;
+        id: string;
+    } | {
+        collectionId: searchSchema.Scalars["String"];
+        isLikedByUser?: searchSchema.Maybe<searchSchema.Scalars["Boolean"]>;
+        likesNum?: searchSchema.Maybe<searchSchema.Scalars["Int"]>;
+        collectionAssetsPage?: searchSchema.Maybe<searchSchema.IAssetsPage>;
+        id: string;
+    }>;
+    resetLikes: () => void;
+};