@ludo.ninja/components 2.0.0 → 2.0.2

package/build/entities/user/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/fonts/FontsInitializeLayout.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+declare const FontsInitializeLayout: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const GlobalFontsFallback: import("styled-components").RuleSet<object>;
+export default FontsInitializeLayout;

package/build/fonts/FontsInitializeLayout.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalFontsFallback = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const google_1 = require("next/font/google");
+const styled_components_1 = require("styled-components");
+const vars_1 = require("@/fonts/vars");
+// const poppinsFont = Poppins({
+//   subsets: ['latin'],
+//   style: ['normal'],
+//   weight: ['200', '300', '400', '500', '600', '700', '800'],
+// });
+const fallbackPoppins = 'LocalPoppinsFont, sans-serif';
+const fallbackDMSans = 'LocalDMSansFont';
+const poppinsFont = (0, google_1.Poppins)({
+    subsets: ['latin'],
+    weight: ['200', '300', '400', '500', '600', '700', '800'],
+    variable: '--PoppinsFont', //poppinsFontVarCss.variable
+    fallback: ['LocalPoppinsFont, sans-serif'], // fallbackPoppins
+});
+const dmsansFont = (0, google_1.DM_Sans)({
+    subsets: ['latin'],
+    style: ['normal', 'italic'],
+    weight: ['400', '500', '600', '700'],
+    variable: '--DMSansFont', //dmsansFontVarCss.variable
+    fallback: ['LocalDMSansFont'], // fallbackDMSans
+});
+const FontsInitializeLayout = ({ children }) => {
+    (0, react_1.useEffect)(() => {
+        // update fonts to react portal elements
+        document.body.classList.add(poppinsFont.variable);
+        document.body.classList.add(dmsansFont.variable);
+        document.body.style.fontFamily = vars_1.poppinsFontVarCss.css; // initial font family
+    }, []);
+    return ((0, jsx_runtime_1.jsx)("main", { style: { fontFamily: vars_1.poppinsFontVarCss.css }, className: `${dmsansFont.variable} ${poppinsFont.variable}`, children: children }));
+};
+exports.GlobalFontsFallback = (0, styled_components_1.css) `
+  /* poppins-200 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackPoppins};
+    font-style: normal;
+    font-weight: 200;
+    src: url('/fonts/poppins-v21-latin-200.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* poppins-300 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackPoppins};
+    font-style: normal;
+    font-weight: 300;
+    src: url('/fonts/poppins-v21-latin-300.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* poppins-regular - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackPoppins};
+    font-style: normal;
+    font-weight: 400;
+    src: url('/fonts/poppins-v21-latin-regular.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* poppins-500 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackPoppins};
+    font-style: normal;
+    font-weight: 500;
+    src: url('/fonts/poppins-v21-latin-500.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* poppins-600 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackPoppins};
+    font-style: normal;
+    font-weight: 600;
+    src: url('/fonts/poppins-v21-latin-600.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* poppins-700 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackPoppins};
+    font-style: normal;
+    font-weight: 700;
+    src: url('/fonts/poppins-v21-latin-700.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* poppins-800 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackPoppins};
+    font-style: normal;
+    font-weight: 800;
+    src: url('/fonts/poppins-v21-latin-800.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-regular - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: normal;
+    font-weight: 400;
+    src: url('/fonts/dm-sans-v15-latin-regular.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-italic - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: italic;
+    font-weight: 400;
+    src: url('/fonts/dm-sans-v15-latin-italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-500 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: normal;
+    font-weight: 500;
+    src: url('/fonts/dm-sans-v15-latin-500.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-500italic - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: italic;
+    font-weight: 500;
+    src: url('/fonts/dm-sans-v15-latin-500italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-600 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: normal;
+    font-weight: 600;
+    src: url('/fonts/dm-sans-v15-latin-600.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-600italic - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: italic;
+    font-weight: 600;
+    src: url('/fonts/dm-sans-v15-latin-600italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-700 - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: normal;
+    font-weight: 700;
+    src: url('/fonts/dm-sans-v15-latin-700.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+  /* dm-sans-700italic - latin */
+  @font-face {
+    font-display: swap; /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
+    font-family: ${fallbackDMSans};
+    font-style: italic;
+    font-weight: 700;
+    src: url('/fonts/dm-sans-v15-latin-700italic.woff2') format('woff2'); /* Chrome 36+, Opera 23+, Firefox 39+, Safari 12+, iOS 10+ */
+  }
+`;
+exports.default = FontsInitializeLayout;

package/build/fonts/vars.d.ts

@@ -0,0 +1 @@
+export { dmsansFontVarCss, poppinsFontVarCss, } from '@ludo.ninja/ui/build/fonts/vars';

package/build/fonts/vars.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poppinsFontVarCss = exports.dmsansFontVarCss = void 0;
+var vars_1 = require("@ludo.ninja/ui/build/fonts/vars");
+Object.defineProperty(exports, "dmsansFontVarCss", { enumerable: true, get: function () { return vars_1.dmsansFontVarCss; } });
+Object.defineProperty(exports, "poppinsFontVarCss", { enumerable: true, get: function () { return vars_1.poppinsFontVarCss; } });

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

@@ -0,0 +1,2 @@
+import { AppProps } from 'next/app';
+export declare function useApollo(pageProps: AppProps['pageProps']): import("@apollo/client").ApolloClient<import("@apollo/client").NormalizedCacheObject>;

package/build/hooks/apollo/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useApollo = void 0;
+const react_1 = require("react");
+const graphql_1 = require("@/api/graphql");
+const api_1 = require("@ludo.ninja/api");
+const env_1 = require("@/store/env");
+function useApollo(pageProps) {
+    const NEXT_PUBLIC_ENV_DOMAIN = (0, env_1.useEnvStore)((state) => state.NEXT_PUBLIC_ENV_DOMAIN);
+    const state = pageProps[graphql_1.APOLLO_STATE_PROP_NAME];
+    return (0, react_1.useMemo)(() => api_1.graphqlConfig.initializeApollo(state, NEXT_PUBLIC_ENV_DOMAIN), [state]);
+}
+exports.useApollo = useApollo;

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,23 @@
+import { IQueryFetchGalleryV2Args } from '@ludo.ninja/api/build/graphql_tools/__generated__/galleriesHost/schema';
+import CollectionCreationEntity from '@/dto/Collection/CollectionCreationEntity';
+import CreationEntity from '@/dto/CreationEntity';
+import GalleryEntityV2 from '@/dto/GalleryEntityV2';
+declare const useGetFavoriteGallaryCreations: ({ galleryId, itemsCount, }: {
+    galleryId: string;
+    itemsCount: number | null;
+}) => {
+    gallery: GalleryEntityV2[] | null;
+    loading: boolean;
+    creationsList: (CreationEntity | CollectionCreationEntity)[];
+    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,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetFavoriteGallaryCreations = void 0;
+const react_1 = require("react");
+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 type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("@/store/ui");
+const CollectionCreationEntity_1 = __importDefault(require("@/dto/Collection/CollectionCreationEntity"));
+const CreationEntity_1 = __importDefault(require("@/dto/CreationEntity"));
+const GalleryEntityV2_1 = __importDefault(require("@/dto/GalleryEntityV2"));
+const useGetUserFevoritesCreations_1 = require("../useGetUserFevoritesCreations");
+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([new GalleryEntityV2_1.default(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) => new CreationEntity_1.default({
+                    ...asset,
+                    itemType: 'asset',
+                    itemId: asset.assetId,
+                })),
+            ]);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            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) => new CollectionCreationEntity_1.default(collection, 'collection')),
+            ]);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            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,24 @@
+import { IQueryFetchUserFavoritesV2Args } from '@ludo.ninja/api/build/graphql_tools/__generated__/galleriesHost/schema';
+import CollectionCreationEntity from '@/dto/Collection/CollectionCreationEntity';
+import CreationEntity from '@/dto/CreationEntity';
+import GalleryEntityV2 from '@/dto/GalleryEntityV2';
+declare const useGetUserFevoritesCreations: ({ userId, pageSize, pageToken, }: IQueryFetchUserFavoritesV2Args) => {
+    favorites: GalleryEntityV2[];
+    assets: CreationEntity[] | null;
+    collections: CollectionCreationEntity[] | 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: GalleryEntityV2[], takeFirstFour: boolean, pageNumber?: number, totalLength?: number | null): {
+    assetArray: unknown[];
+    collectionsArray: unknown[];
+};

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

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMediaForGallery = exports.useGetUserFevoritesCreations = void 0;
+const react_1 = require("react");
+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 type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("@/store/ui");
+const CollectionCreationEntity_1 = __importDefault(require("@/dto/Collection/CollectionCreationEntity"));
+const CreationEntity_1 = __importDefault(require("@/dto/CreationEntity"));
+const GalleryEntityV2_1 = __importDefault(require("@/dto/GalleryEntityV2"));
+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) => new GalleryEntityV2_1.default(gallery)));
+            setLoading(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong while fetching favorites.',
+            });
+            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) => new CreationEntity_1.default({
+                ...asset,
+                itemType: 'asset',
+                itemId: asset.assetId,
+            })));
+            setLoading(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            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) => new CollectionCreationEntity_1.default(collection)));
+            setLoading(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            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.getGalleryCreationIds().slice(0, 4)
+            : fav.getGalleryCreationIds();
+        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 };
+}
+exports.getMediaForGallery = getMediaForGallery;