@ludo.ninja/components 1.5.7 → 1.5.9

package/src/hooks/favorites/useGetFavoriteGallaryCreations/index.ts

@@ -1,175 +0,0 @@
-import { useEffect, useState } from 'react';
-
-import { useLazyQuery, useQuery } from '@apollo/client';
-
-import { hosts, assetSchema, collectionsSchema, galleriesSchema, searchSchema } from '@ludo.ninja/api';
-import { alertVariants } from '@ludo.ninja/ui/build/system/Alert/type';
-
-import { useUiStore } from '@/store/ui';
-
-import CollectionCreationEntity from '@/dto/Collection/CollectionCreationEntity';
-import CreationEntity from '@/dto/CreationEntity';
-import GalleryEntityV2 from '@/dto/GalleryEntityV2';
-
-import { getMediaForGallery } from "@/hooks/favorites";
-
-const useGetFavoriteGallaryCreations = ({
-  galleryId,
-  itemsCount,
-}: {
-  galleryId: string;
-  itemsCount: number | null;
-}) => {
-  const [gallery, setGallery] = useState<GalleryEntityV2[] | null>([]);
-  const [assets, setAssets] = useState<CreationEntity[] | null>(null);
-  const [collections, setCollections] = useState<
-    CollectionCreationEntity[] | null
-  >(null);
-
-  const [currentPage, setCurrentPage] = useState<number>(1);
-  const [loading, setLoading] = useState<boolean>(true);
-  const [fetchError, setFetchError] = useState<boolean>(false);
-  const [allResults, setAllResults] = useState<number | null>(null);
-  const openAlert = useUiStore((state) => state.openAlert);
-
-  const {
-    error: galleryError,
-    loading: galleryLoading,
-    refetch,
-  } = useQuery(galleriesSchema.FetchGalleryV2Document, {
-    variables: { galleryId },
-    context: {
-      uri: hosts.galleriesHost,
-    },
-    notifyOnNetworkStatusChange: true,
-    fetchPolicy: 'no-cache',
-    onCompleted: ({ fetchGalleryV2 }) => {
-      setGallery([new GalleryEntityV2(fetchGalleryV2)]);
-      setAllResults(fetchGalleryV2.items);
-    },
-    onError: () => {
-      setGallery(null);
-      setLoading(false);
-      setFetchError(true);
-      setAllResults(0);
-    },
-  });
-
-  const [fetchAssets, { loading: assetsLoading, error: assetsError }] =
-    useLazyQuery(searchSchema.FetchAssetsDocument, {
-      context: { uri: hosts.searchHost },
-      fetchPolicy: 'no-cache',
-      onCompleted: ({ fetchAssets: data }) => {
-        setAssets((prevAssets) => [
-          ...(prevAssets || []),
-          ...data.map(
-            (asset: assetSchema.IAsset) =>
-              new CreationEntity({
-                ...asset,
-                itemType: 'asset',
-                itemId: asset.assetId,
-              } as unknown as searchSchema.ICreation)
-          ),
-        ]);
-      },
-      onError: () => {
-        openAlert({
-          type: alertVariants.error,
-
-          caption: 'Oops, something went wrong.',
-        });
-        setAssets([]);
-        setFetchError(true);
-      },
-    });
-
-  const [
-    fetchCollections,
-    { loading: collectionsLoading, error: collectionsError },
-  ] = useLazyQuery(searchSchema.FetchCollectionsByIdsDocument, {
-    context: { uri: hosts.searchHost },
-    fetchPolicy: 'no-cache',
-    onCompleted: ({ fetchCollectionsByIds: data }) => {
-      setCollections((prevCollections) => [
-        ...(prevCollections || []),
-        ...data.map(
-          (collection: collectionsSchema.ICollectionAsset) =>
-            new CollectionCreationEntity(collection, 'collection')
-        ),
-      ]);
-    },
-    onError: () => {
-      openAlert({
-        type: alertVariants.error,
-
-        caption: 'Oops, something went wrong.',
-      });
-      setCollections([]);
-      setFetchError(true);
-    },
-  });
-
-  useEffect(() => {
-    if (gallery && gallery.length > 0) {
-      const { assetArray, collectionsArray } = 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,
-  }: galleriesSchema.IQueryFetchGalleryV2Args) {
-    await refetch({ galleryId });
-  }
-
-  function loadMore() {
-    if (!gallery) return;
-    else {
-      setLoading(true);
-      setCurrentPage((prevPage) => ++prevPage);
-    }
-  }
-
-  type Creations = (CreationEntity | CollectionCreationEntity)[];
-  const creations: Creations = [...(assets || []), ...(collections || [])];
-
-  return {
-    gallery,
-    loading,
-    creationsList: creations,
-    loadingAssets: assetsLoading,
-    loadingGallery: galleryLoading,
-    loadingCollections: collectionsLoading,
-    errorAssets: assetsError,
-    errorCollections: collectionsError,
-    errorGallery: galleryError,
-    fetchError,
-    allResults,
-    refetchQueryGalleryCreation,
-    loadMore,
-  };
-};
-
-export { useGetFavoriteGallaryCreations };

package/src/hooks/favorites/useGetUserFevoritesCreations/index.ts

@@ -1,243 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-
-import { useLazyQuery, useQuery } from '@apollo/client';
-
-import { hosts, assetSchema, collectionsSchema, galleriesSchema, searchSchema } from '@ludo.ninja/api';
-
-import { alertVariants } from '@ludo.ninja/ui/build/system/Alert/type';
-
-import { useUiStore } from '@/store/ui';
-
-import CollectionCreationEntity from '@/dto/Collection/CollectionCreationEntity';
-import CreationEntity from '@/dto/CreationEntity';
-import GalleryEntityV2 from '@/dto/GalleryEntityV2';
-
-const maxUserFavoritesLength = 1000;
-
-const useGetUserFevoritesCreations = ({
-  userId,
-  pageSize,
-  pageToken,
-}: galleriesSchema.IQueryFetchUserFavoritesV2Args) => {
-  const [assets, setAsset] = useState<CreationEntity[] | null>(null);
-  const [collections, setCollections] = useState<
-    CollectionCreationEntity[] | null
-  >(null);
-  const [favorites, setFavorites] = useState<GalleryEntityV2[]>([]);
-  const [loading, setLoading] = useState<boolean>(true);
-  const openAlert = useUiStore((state) => state.openAlert);
-
-  const nextPageToken = useRef<string | null>(null);
-  const [isNextLoading, setIsNextLoading] = 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,
-  } = useQuery(galleriesSchema.FetchUserFavoritesV2Document, {
-    context: { uri: 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: galleriesSchema.IGalleryV2) => new GalleryEntityV2(gallery))
-      );
-      setLoading(false);
-    },
-    onError: () => {
-      openAlert({
-        type: alertVariants.error,
-
-        caption: 'Oops, something went wrong while fetching favorites.',
-      });
-      setFavorites([]);
-      setLoading(false);
-    },
-  });
-
-  const [fetchAssets, { loading: assetsLoading, error: assetsError }] =
-    useLazyQuery(searchSchema.FetchAssetsDocument, {
-      context: { uri: hosts.searchHost },
-      fetchPolicy: 'no-cache',
-      onCompleted: ({ fetchAssets: data }) => {
-        setAsset(
-          data.map(
-            (asset: assetSchema.IAsset) =>
-              new CreationEntity({
-                ...asset,
-                itemType: 'asset',
-                itemId: asset.assetId,
-              } as unknown as searchSchema.ICreation)
-          )
-        );
-        setLoading(false);
-      },
-      onError: () => {
-        openAlert({
-          type: alertVariants.error,
-
-          caption: 'Oops, something went wrong.',
-        });
-        setAsset(null);
-        setLoading(false);
-      },
-    });
-
-  const [
-    fetchCollections,
-    { loading: collectionsLoading, error: collectionsError },
-  ] = useLazyQuery(searchSchema.FetchCollectionsByIdsDocument, {
-    context: { uri: hosts.searchHost },
-    fetchPolicy: 'no-cache',
-    onCompleted: ({ fetchCollectionsByIds: data }) => {
-      setCollections(
-        data.map(
-          (collection: collectionsSchema.ICollectionAsset) =>
-            new CollectionCreationEntity(collection)
-        )
-      );
-      setLoading(false);
-    },
-    onError: () => {
-      openAlert({
-        type: alertVariants.error,
-
-        caption: 'Oops, something went wrong.',
-      });
-      setCollections(null);
-      setLoading(false);
-    },
-  });
-
-  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.hasOwn('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,
-  };
-};
-
-export { useGetUserFevoritesCreations };
-
-export function getMediaForGallery(
-  favorites: GalleryEntityV2[],
-  takeFirstFour: boolean,
-  pageNumber = 1,
-  totalLength?: number | null
-) {
-  if (favorites.length === 0) return { assetArray: [], collectionsArray: [] };
-
-  const itemsPerPage = 40;
-  const assetArray: unknown[] = [];
-  const collectionsArray: unknown[] = [];
-
-  favorites.forEach((fav: GalleryEntityV2) => {
-    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 };
-}

package/src/hooks/galleries/index.ts

@@ -1 +0,0 @@
-export * from './useGetUserGalleriesCreations';

package/src/hooks/galleries/useGetUserGalleriesCreations/index.ts

@@ -1,201 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-
-import { useLazyQuery, useQuery } from '@apollo/client';
-
-import { hosts } from '@ludo.ninja/api';
-import {
-  galleriesSchema,
-  searchSchema,
-  collectionsSchema,
-  assetSchema
-} from '@ludo.ninja/api';
-import { alertVariants } from '@ludo.ninja/ui/build/system/Alert/type';
-
-import { useUiStore } from '@/store/ui';
-
-import CollectionCreationEntity from '@/dto/Collection/CollectionCreationEntity';
-import CreationEntity from '@/dto/CreationEntity';
-import GalleryEntityV2 from '@/dto/GalleryEntityV2';
-import { getMediaForGallery } from "@/hooks/favorites";
-
-const maxUserFavoritesLength = 1000;
-
-const useGetUserGalleriesCreations = ({
-  userId,
-  pageSize,
-  pageToken,
-}: galleriesSchema.IQueryFetchUserGalleriesV2Args) => {
-  const [assets, setAsset] = useState<CreationEntity[] | null>(null);
-  const [collections, setCollections] = useState<
-    CollectionCreationEntity[] | null
-  >(null);
-  const [galleries, setGalleries] = useState<GalleryEntityV2[]>([]);
-  const [loading, setLoading] = useState<boolean>(true);
-  const openAlert = useUiStore((state) => state.openAlert);
-
-  const nextPageToken = useRef<string | null>(null);
-  const [isNextLoading, setIsNextLoading] = 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,
-  } = useQuery(galleriesSchema.FetchUserGalleriesV2Document, {
-    context: { uri: 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: galleriesSchema.IGalleryV2) => new GalleryEntityV2(gallery))
-      );
-      setLoading(false);
-    },
-    onError: () => {
-      openAlert({
-        type: alertVariants.error,
-
-        caption: 'Oops, something went wrong while fetching galleries.',
-      });
-      setGalleries([]);
-      setLoading(false);
-    },
-  });
-
-  const [fetchAssets, { loading: assetsLoading, error: assetsError }] =
-    useLazyQuery(searchSchema.FetchAssetsDocument, {
-      context: { uri: hosts.searchHost },
-      fetchPolicy: 'no-cache',
-      onCompleted: ({ fetchAssets: data }) => {
-        setAsset(
-          data.map(
-            (asset: assetSchema.IAsset) =>
-              new CreationEntity({
-                ...asset,
-                itemType: 'asset',
-                itemId: asset.assetId,
-              } as unknown as searchSchema.ICreation)
-          )
-        );
-        setLoading(false);
-      },
-      onError: () => {
-        openAlert({
-          type: alertVariants.error,
-
-          caption: 'Oops, something went wrong.',
-        });
-        setAsset(null);
-        setLoading(false);
-      },
-    });
-
-  const [
-    fetchCollections,
-    { loading: collectionsLoading, error: collectionsError },
-  ] = useLazyQuery(searchSchema.FetchCollectionsByIdsDocument, {
-    context: { uri: hosts.searchHost },
-    fetchPolicy: 'no-cache',
-    onCompleted: ({ fetchCollectionsByIds: data }) => {
-      setCollections(
-        data.map(
-          (collection: collectionsSchema.ICollectionAsset) =>
-            new CollectionCreationEntity(collection)
-        )
-      );
-      setLoading(false);
-    },
-    onError: () => {
-      openAlert({
-        type: alertVariants.error,
-
-        caption: 'Oops, something went wrong.',
-      });
-      setCollections(null);
-      setLoading(false);
-    },
-  });
-
-  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.hasOwn('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,
-  };
-};
-
-export { useGetUserGalleriesCreations };

package/src/hooks/index.ts

@@ -1,8 +0,0 @@
-export * from './likes/useGetLikesAsset';
-export * from './apollo';
-export * from './favorites';
-export * from './galleries';
-export * from './searchFiltersConnector';
-
-
-