@ludo.ninja/components 2.3.36 → 2.3.38

package/build/hoc/HOCSignUpInterceptor/HOCSignUpInterceptor.d.ts

@@ -0,0 +1,2 @@
+import { ReactNode } from "react";
+export declare const HOCSignUpInterceptor: (Component: ReactNode, isAuthorized?: boolean) => string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<import("react").AwaitedReactNode> | null | undefined;

package/build/hoc/HOCSignUpInterceptor/HOCSignUpInterceptor.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOCSignUpInterceptor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const CircleSvg_1 = require("./CircleSvg");
+const LWithSearchHeader_1 = __importDefault(require("../../layouts/base/LWithSearchHeader"));
+const store_1 = require("../../modules/user/store");
+const redirectToApp_1 = require("../../utils/redirectToApp");
+const ScreenWidth_1 = require("@ludo.ninja/ui/build/styles/ScreenWidth");
+const MainButton_1 = __importDefault(require("@ludo.ninja/ui/build/system/Buttons/MainButton"));
+const _4k_1 = require("@ludo.ninja/ui/build/utils/4k");
+const styled_components_1 = __importDefault(require("styled-components"));
+const SWrapper = styled_components_1.default.div `
+  padding-top: 132px;
+
+  ${ScreenWidth_1.mediaQuery.mobile} {
+    padding-top: 82px;
+    overflow-x: hidden;
+    min-height: var(--app-height);
+  }
+
+  ${ScreenWidth_1.mediaQuery.minWidthFourK} {
+    padding-top: ${(0, _4k_1.adaptiveValueCalc)(132)};
+  }
+`;
+const SContainer = styled_components_1.default.div `
+  position: relative;
+  display: flex;
+  justify-content: center;
+
+  & > svg {
+    height: 570px;
+    transform: scale(1.25) translateY(24px);
+  }
+
+  ${ScreenWidth_1.mediaQuery.mobile} {
+    height: 486px;
+
+    & > svg {
+      position: absolute;
+      height: 486px;
+      transform: scale(1.25) translateY(20px);
+    }
+  }
+`;
+const SContent = styled_components_1.default.div `
+  position: absolute;
+  left: 50%;
+  top: 200px;
+  transform: translate(-50%, 0);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 46px;
+
+  .textLogin {
+    color: #696f90;
+    text-align: center;
+    font-size: 40px;
+    font-weight: 700;
+    line-height: 52px;
+    max-width: 500px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+  }
+
+  ${ScreenWidth_1.mediaQuery.mobile} {
+    top: 144px;
+    gap: 29px;
+
+    .textLogin {
+      font-size: 28px;
+      line-height: 36px;
+      max-width: 330px;
+    }
+  }
+`;
+const SignUpProtected = () => {
+    return ((0, jsx_runtime_1.jsx)(LWithSearchHeader_1.default, { children: (0, jsx_runtime_1.jsx)(SWrapper, { children: (0, jsx_runtime_1.jsxs)(SContainer, { children: [(0, jsx_runtime_1.jsx)(CircleSvg_1.CircleSvg, {}), (0, jsx_runtime_1.jsxs)(SContent, { children: [(0, jsx_runtime_1.jsxs)("p", { className: "textLogin", children: [(0, jsx_runtime_1.jsx)("span", { children: "Please log in" }), (0, jsx_runtime_1.jsx)("span", { children: "to proceed on this page" })] }), (0, jsx_runtime_1.jsx)("div", { children: (0, jsx_runtime_1.jsx)(MainButton_1.default, { onClick: redirectToApp_1.redirectToApp, variant: "primaryM", text: "Go to App" }) })] })] }) }) }));
+};
+// for initialize hoc use template :
+// const Page = (props: any) => {
+//   return HOCSignUpInterceptor(<HomeBuildPage {...props} />);
+// };
+// export default Page;
+const HOCSignUpInterceptor = (Component, isAuthorized) => {
+    const isSignedIn = (0, store_1.useUserStore)((state) => state.isSignedIn);
+    if (typeof isAuthorized !== "undefined") {
+        if (!isAuthorized) {
+            return (0, jsx_runtime_1.jsx)(SignUpProtected, {});
+        }
+        return Component;
+    }
+    if (!isSignedIn) {
+        return (0, jsx_runtime_1.jsx)(SignUpProtected, {});
+    }
+    return Component;
+};
+exports.HOCSignUpInterceptor = HOCSignUpInterceptor;

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

@@ -0,0 +1 @@
+export declare function useApollo(pageProps?: any): import("@apollo/client").ApolloClient<import("@apollo/client").NormalizedCacheObject>;

package/build/hooks/apollo/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useApollo = useApollo;
+const react_1 = require("react");
+const graphql_1 = require("../../api/graphql");
+const api_1 = require("@ludo.ninja/api");
+const env_1 = require("../../store/env");
+const nookies_1 = require("nookies");
+const ludoDomains_1 = require("@ludo.ninja/core/build/ludoDomains");
+function useApollo(pageProps) {
+    const { NEXT_PUBLIC_ENV_VALUE, NEXT_PUBLIC_ENV_DOMAIN } = (0, env_1.useEnvStore)((state) => ({
+        NEXT_PUBLIC_ENV_VALUE: state.NEXT_PUBLIC_ENV_VALUE,
+        NEXT_PUBLIC_ENV_DOMAIN: state.NEXT_PUBLIC_ENV_DOMAIN,
+    }));
+    const state = pageProps?.[graphql_1.APOLLO_STATE_PROP_NAME] || null;
+    return (0, react_1.useMemo)(() => api_1.graphqlConfig.createErrorAuthInterceptor(api_1.graphqlConfig.initializeApollo(state, NEXT_PUBLIC_ENV_DOMAIN), () => {
+        api_1.authCookies.destroyCookies(NEXT_PUBLIC_ENV_DOMAIN);
+        (0, nookies_1.destroyCookie)(null, "authMultiversXWallet", {
+            path: "/",
+            domain: NEXT_PUBLIC_ENV_DOMAIN,
+        });
+        window.location.replace(`${ludoDomains_1.ludoDomains[NEXT_PUBLIC_ENV_VALUE]["welcome"]}?alertError=authServerError`);
+    }), [state]);
+}

package/build/hooks/audio/useMultiAudio/index.d.ts

@@ -0,0 +1,2 @@
+declare const useMultiAudio: () => void;
+export default useMultiAudio;

package/build/hooks/audio/useMultiAudio/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const router_1 = require("next/router");
+const media_1 = require("../../../store/media");
+const useMultiAudio = () => {
+    const tracks = (0, media_1.useMediaStore)((state) => state.audioTracks);
+    const setTracks = (0, media_1.useMediaStore)((state) => state.setAudioTracks);
+    const router = (0, router_1.useRouter)();
+    (0, react_1.useEffect)(() => {
+        const ifExist = tracks.some((track) => {
+            return track.playing;
+        });
+        if (ifExist) {
+            const newTracks = [...tracks].map((track) => {
+                track.playing = false;
+                track.audio.currentTime = 0;
+                return track;
+            });
+            setTracks(newTracks);
+        }
+    }, [router]);
+    (0, react_1.useEffect)(() => {
+        tracks.map((track) => {
+            track.playing ? track.audio.play() : track.audio.pause();
+        });
+    }, [tracks]);
+    (0, react_1.useEffect)(() => {
+        tracks.forEach((source, i) => {
+            source.audio.addEventListener('ended', () => {
+                const newTracks = [...tracks];
+                newTracks[i].playing = false;
+                setTracks(newTracks);
+            });
+        });
+        return () => {
+            tracks.forEach((source, i) => {
+                source.audio.removeEventListener('ended', () => {
+                    const newTracks = [...tracks];
+                    newTracks[i].playing = false;
+                    setTracks(newTracks);
+                });
+            });
+        };
+    }, []);
+};
+exports.default = useMultiAudio;

package/build/hooks/extension/useExtension/index.d.ts

@@ -0,0 +1,7 @@
+declare const useExtension: () => {
+    isExtensionInstalled: boolean;
+    openExtension: () => void;
+    openExtensionChromeStorePage: () => void;
+    pingExtension: () => Promise<void>;
+};
+export default useExtension;

package/build/hooks/extension/useExtension/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const utils_1 = require("@ludo.ninja/utils");
+const useExtension = () => {
+    const [isExtensionInstalled, setIsExtensionInstalled] = (0, react_1.useState)(false);
+    const pingExtension = (0, react_1.useCallback)(async () => {
+        try {
+            const response = (await (0, utils_1.sendEventToExtension)(utils_1.eventsTypes.pingVersion));
+            setIsExtensionInstalled(Boolean(response?.version));
+        }
+        catch (e) {
+            setIsExtensionInstalled(false);
+        }
+    }, [setIsExtensionInstalled]);
+    (0, react_1.useEffect)(() => {
+        pingExtension();
+    }, []);
+    return {
+        isExtensionInstalled,
+        openExtension,
+        openExtensionChromeStorePage,
+        pingExtension,
+    };
+};
+exports.default = useExtension;
+const openExtension = () => {
+    (0, utils_1.sendEventToExtension)(utils_1.eventsTypes.openExtension);
+};
+const openExtensionChromeStorePage = () => {
+    window.open('https://chromewebstore.google.com/detail/ludo-x/fgcmebogmgdheonhhefnblfodobpmfip', '_blank');
+};

package/build/hooks/favorites/useGetFavoriteGallaryCreations/index.d.ts

@@ -0,0 +1,22 @@
+import { TCreation } from '../../../entities/creation/types';
+import { TGallery } from '../../../entities/gallery/types';
+import { IQueryFetchGalleryV2Args } from "@ludo.ninja/api/build/graphql_tools/__generated__/galleriesHost/schema";
+declare const useGetFavoriteGallaryCreations: ({ galleryId, itemsCount, }: {
+    galleryId: string;
+    itemsCount: number | null;
+}) => {
+    gallery: TGallery[] | null;
+    loading: boolean;
+    creationsList: TCreation[];
+    loadingAssets: boolean;
+    loadingGallery: boolean;
+    loadingCollections: boolean;
+    errorAssets: import("@apollo/client").ApolloError | undefined;
+    errorCollections: import("@apollo/client").ApolloError | undefined;
+    errorGallery: import("@apollo/client").ApolloError | undefined;
+    fetchError: boolean;
+    allResults: number | null;
+    refetchQueryGalleryCreation: ({ galleryId }: IQueryFetchGalleryV2Args) => Promise<void>;
+    loadMore: () => void;
+};
+export { useGetFavoriteGallaryCreations };

package/build/hooks/favorites/useGetFavoriteGallaryCreations/index.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetFavoriteGallaryCreations = void 0;
+const useGetUserFevoritesCreations_1 = require("../useGetUserFevoritesCreations");
+const builder_1 = require("../../../entities/creation/builder");
+const collectionCreationBuilder_1 = require("../../../entities/creation/collectionCreationBuilder");
+const builder_2 = require("../../../entities/gallery/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__/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 useGetFavoriteGallaryCreations = ({ galleryId, itemsCount, }) => {
+    const [gallery, setGallery] = (0, react_1.useState)([]);
+    const [assets, setAssets] = (0, react_1.useState)(null);
+    const [collections, setCollections] = (0, react_1.useState)(null);
+    const [currentPage, setCurrentPage] = (0, react_1.useState)(1);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [fetchError, setFetchError] = (0, react_1.useState)(false);
+    const [allResults, setAllResults] = (0, react_1.useState)(null);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { error: galleryError, loading: galleryLoading, refetch, } = (0, client_1.useQuery)(schema_1.FetchGalleryV2Document, {
+        variables: { galleryId },
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        notifyOnNetworkStatusChange: true,
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchGalleryV2 }) => {
+            setGallery([(0, builder_2.buildGallery)(fetchGalleryV2)]);
+            setAllResults(fetchGalleryV2.items);
+        },
+        onError: () => {
+            setGallery(null);
+            setLoading(false);
+            setFetchError(true);
+            setAllResults(0);
+        },
+    });
+    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 }) => {
+            setAssets((prevAssets) => [
+                ...(prevAssets || []),
+                ...data.map((asset) => (0, builder_1.buildCreation)({
+                    ...asset,
+                    itemType: "asset",
+                    itemId: asset.assetId,
+                })),
+            ]);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setAssets([]);
+            setFetchError(true);
+        },
+    });
+    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((prevCollections) => [
+                ...(prevCollections || []),
+                ...data.map((collection) => (0, collectionCreationBuilder_1.buildCollectionCreation)(collection, types_1.LabelKeys.collection)),
+            ]);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setCollections([]);
+            setFetchError(true);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (gallery && gallery.length > 0) {
+            const { assetArray, collectionsArray } = (0, useGetUserFevoritesCreations_1.getMediaForGallery)(gallery, false, currentPage, itemsCount);
+            const assetPromise = assetArray.length > 0 ? fetchAssets({ variables: { assetIds: assetArray } }) : Promise.resolve();
+            const collectionsPromise = collectionsArray.length > 0
+                ? fetchCollections({ variables: { collectionIds: collectionsArray } })
+                : Promise.resolve();
+            Promise.all([assetPromise, collectionsPromise])
+                .then(() => {
+                setLoading(false);
+            })
+                .catch(() => {
+                setLoading(false);
+                setFetchError(true);
+            });
+        }
+    }, [gallery, fetchAssets, fetchCollections, currentPage]);
+    async function refetchQueryGalleryCreation({ galleryId }) {
+        await refetch({ galleryId });
+    }
+    function loadMore() {
+        if (!gallery)
+            return;
+        else {
+            setLoading(true);
+            setCurrentPage((prevPage) => ++prevPage);
+        }
+    }
+    const creations = [...(assets || []), ...(collections || [])];
+    return {
+        gallery,
+        loading,
+        creationsList: creations,
+        loadingAssets: assetsLoading,
+        loadingGallery: galleryLoading,
+        loadingCollections: collectionsLoading,
+        errorAssets: assetsError,
+        errorCollections: collectionsError,
+        errorGallery: galleryError,
+        fetchError,
+        allResults,
+        refetchQueryGalleryCreation,
+        loadMore,
+    };
+};
+exports.useGetFavoriteGallaryCreations = useGetFavoriteGallaryCreations;

package/build/hooks/favorites/useGetUserFevoritesCreations/index.d.ts

@@ -0,0 +1,23 @@
+import { TCreation } from '../../../entities/creation/types';
+import { TGallery } from '../../../entities/gallery/types';
+import { IQueryFetchUserFavoritesV2Args } from "@ludo.ninja/api/build/graphql_tools/__generated__/galleriesHost/schema";
+declare const useGetUserFevoritesCreations: ({ userId, pageSize, pageToken }: IQueryFetchUserFavoritesV2Args) => {
+    favorites: TGallery[];
+    assets: TCreation[] | null;
+    collections: TCreation[] | null;
+    loading: boolean;
+    loadingAssets: boolean;
+    loadingFavorites: boolean;
+    loadingCollections: boolean;
+    errorAssets: import("@apollo/client").ApolloError | undefined;
+    errorCollections: import("@apollo/client").ApolloError | undefined;
+    errorFavorites: import("@apollo/client").ApolloError | undefined;
+    refetchQueryFavoritesList: () => Promise<void>;
+    loadMoreFavoritesList: () => Promise<void>;
+    isNextLoading: boolean;
+};
+export { useGetUserFevoritesCreations };
+export declare function getMediaForGallery(favorites: TGallery[], takeFirstFour: boolean, pageNumber?: number, totalLength?: number | null): {
+    assetArray: unknown[];
+    collectionsArray: unknown[];
+};

package/build/hooks/favorites/useGetUserFevoritesCreations/index.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetUserFevoritesCreations = 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 useGetUserFevoritesCreations = ({ userId, pageSize, pageToken }) => {
+    const [assets, setAsset] = (0, react_1.useState)(null);
+    const [collections, setCollections] = (0, react_1.useState)(null);
+    const [favorites, setFavorites] = (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: favoritesError, refetch, fetchMore, } = (0, client_1.useQuery)(schema_1.FetchUserFavoritesV2Document, {
+        context: { uri: api_1.hosts.galleriesHost }, //todo : update variables to object page
+        variables: { pageSize, userId, pageToken },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchUserFavoritesV2: { galleries, nextPageToken: token } }) => {
+            // nextPageToken.current = nextPage.nextPage?.token || null;
+            nextPageToken.current = token || null;
+            setFavorites(galleries.map((gallery) => (0, builder_2.buildGallery)(gallery)));
+            setLoading(false);
+        },
+        onError: (err) => {
+            openAlert((0, getErrorAlertProps_1.getErrorAlertProps)(err));
+            setFavorites([]);
+            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 (favorites.length > 0) {
+            const { assetArray, collectionsArray } = getMediaForGallery(favorites, true);
+            if (assetArray.length > 0) {
+                fetchAssets({ variables: { assetIds: assetArray } });
+            }
+            if (collectionsArray.length > 0) {
+                fetchCollections({ variables: { collectionIds: collectionsArray } });
+            }
+        }
+    }, [favorites, fetchAssets, fetchCollections]);
+    async function refetchQueryFavoritesList() {
+        await refetch();
+    }
+    async function loadMoreFavoritesList() {
+        if (!nextPageToken.current || !isHaveNextPage || favorites.length >= maxUserFavoritesLength)
+            return;
+        setIsNextLoading(true);
+        try {
+            await fetchMore({
+                variables: { pageToken: nextPageToken.current },
+                updateQuery: (prev, { fetchMoreResult }) => {
+                    if (!fetchMoreResult)
+                        return prev;
+                    const { nextPageToken: token, favorites: nextFavorites } = fetchMoreResult.fetchMyFavoritesV2;
+                    nextPageToken.current = token || null;
+                    if (prev !== null && prev.hasOwnProperty("fetchMyFavoritesV2")) {
+                        const { favorites: prevFavorites } = prev.fetchMyFavoritesV2;
+                        return {
+                            fetchMyFavorites: {
+                                favorites: [...prevFavorites, ...nextFavorites],
+                                nextPageToken: token,
+                            },
+                        };
+                    }
+                    else {
+                        return {
+                            fetchMyFavorites: {
+                                favorites: nextFavorites,
+                                nextPageToken: token,
+                            },
+                        };
+                    }
+                },
+            });
+        }
+        catch (e) {
+            //====
+        }
+        finally {
+            setIsNextLoading(false);
+        }
+    }
+    return {
+        favorites,
+        assets,
+        collections,
+        loading,
+        loadingAssets: assetsLoading,
+        loadingFavorites: favoritesLoading,
+        loadingCollections: collectionsLoading,
+        errorAssets: assetsError,
+        errorCollections: collectionsError,
+        errorFavorites: favoritesError,
+        refetchQueryFavoritesList,
+        loadMoreFavoritesList,
+        isNextLoading,
+    };
+};
+exports.useGetUserFevoritesCreations = useGetUserFevoritesCreations;
+function getMediaForGallery(favorites, takeFirstFour, pageNumber = 1, totalLength) {
+    if (favorites.length === 0)
+        return { assetArray: [], collectionsArray: [] };
+    const itemsPerPage = 40;
+    const assetArray = [];
+    const collectionsArray = [];
+    favorites.forEach((fav) => {
+        const creationIds = takeFirstFour ? fav.creationIds.slice(0, 4) : fav.creationIds;
+        if (!creationIds || creationIds.length === 0)
+            return;
+        const startIndex = (pageNumber - 1) * itemsPerPage;
+        const endIndex = totalLength ? totalLength : startIndex + itemsPerPage;
+        for (let i = startIndex; i < endIndex && 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/galleries/useGetUserGalleriesCreations/index.d.ts

@@ -0,0 +1,23 @@
+import { TCreation } from '../../../entities/creation/types';
+import { TGallery } from '../../../entities/gallery/types';
+import { IQueryFetchUserGalleriesV2Args } from "@ludo.ninja/api/build/graphql_tools/__generated__/galleriesHost/schema";
+declare const useGetUserGalleriesCreations: ({ userId, pageSize, pageToken }: IQueryFetchUserGalleriesV2Args) => {
+    galleries: TGallery[];
+    assets: TCreation[] | null;
+    collections: TCreation[] | null;
+    loading: boolean;
+    loadingAssets: boolean;
+    loadingFavorites: boolean;
+    loadingCollections: boolean;
+    errorAssets: import("@apollo/client").ApolloError | undefined;
+    errorCollections: import("@apollo/client").ApolloError | undefined;
+    errorGalleries: import("@apollo/client").ApolloError | undefined;
+    refetchQueryGalleriesList: () => Promise<void>;
+    loadMoreGalleriesList: () => Promise<void>;
+    isNextLoading: boolean;
+};
+export { useGetUserGalleriesCreations };
+export declare function getMediaForGallery(favorites: TGallery[], takeFirstFour: boolean): {
+    assetArray: unknown[];
+    collectionsArray: unknown[];
+};