@ludo.ninja/components 2.0.1 → 2.0.2

package/build/api/server-galleries/mutations/useAddCollectionsToGallery/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAddCollectionsToGalleryV2 = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useAddCollectionsToGalleryV2 = () => {
+    const [isAdded, setAdd] = (0, react_1.useState)(false);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.galleriesSchema.AddCollectionsToGalleryV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ addCollectionsToGallery }) => {
+            setAdd(addCollectionsToGallery);
+        },
+        refetchQueries: [
+            api_1.galleriesSchema.FetchUserFavoritesV2Document,
+            api_1.galleriesSchema.FetchUserGalleriesV2Document,
+        ],
+        // onError: (err) => console.log(err),
+    });
+    return { addCollectionToGallery, error, isAdded };
+    async function addCollectionToGallery({ galleryId, collectionIds, }) {
+        try {
+            await mutate({
+                variables: { galleryId, collectionIds },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useAddCollectionsToGalleryV2 = useAddCollectionsToGalleryV2;

package/build/api/server-galleries/mutations/useAddCreationsToGallery/index.d.ts

@@ -0,0 +1,7 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+declare const useAddCreationsToGalleryV2: () => {
+    addCreationsToGallery: ({ galleryId, creationIds, }: schema.IMutationAddCreationsToGalleryV2Args) => Promise<void>;
+    error: import("@apollo/client").ApolloError | undefined;
+    isAdded: boolean;
+};
+export { useAddCreationsToGalleryV2 };

package/build/api/server-galleries/mutations/useAddCreationsToGallery/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAddCreationsToGalleryV2 = void 0;
+const react_1 = require("react");
+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 ui_1 = require("@/store/ui");
+const useAddCreationsToGalleryV2 = () => {
+    const [isAdded, setAdd] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.galleriesSchema.AddCreationsToGalleryV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ addCreationsToGalleryV2 }) => {
+            setAdd(addCreationsToGalleryV2);
+            openAlert({
+                type: type_1.alertVariants.success,
+                text: '',
+                // caption: 'Successfully added',
+            });
+        },
+        refetchQueries: [
+            api_1.galleriesSchema.FetchUserFavoritesV2Document,
+            api_1.galleriesSchema.FetchUserGalleriesV2Document,
+        ],
+        // onError: (err) => console.log(err),
+    });
+    return { addCreationsToGallery, error, isAdded };
+    async function addCreationsToGallery({ galleryId, creationIds, }) {
+        try {
+            await mutate({
+                variables: { galleryId, creationIds },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useAddCreationsToGalleryV2 = useAddCreationsToGalleryV2;

package/build/api/server-galleries/mutations/useCreateFavorites/index.d.ts

@@ -0,0 +1,6 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+declare const useCreateFavoriteListV2: () => {
+    createFavorites: ({ name, description, publicAccessible, creationIds, }: schema.IMutationCreateFavoriteListV2Args) => Promise<void>;
+    errorCreateFavorites: import("@apollo/client").ApolloError | undefined;
+};
+export { useCreateFavoriteListV2 };

package/build/api/server-galleries/mutations/useCreateFavorites/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateFavoriteListV2 = void 0;
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useCreateFavoriteListV2 = () => {
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.galleriesSchema.CreateFavoriteListV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+    });
+    return { createFavorites: createFavoriteList, errorCreateFavorites: error };
+    async function createFavoriteList({ name, description, publicAccessible, creationIds, }) {
+        try {
+            await mutate({
+                variables: { name, description, publicAccessible, creationIds },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useCreateFavoriteListV2 = useCreateFavoriteListV2;

package/build/api/server-galleries/mutations/useCreateGallery/index.d.ts

@@ -0,0 +1,6 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+declare const useCreateGalleryV2: () => {
+    createGallery: ({ name, description, publicAccessible, creationIds, }: schema.IMutationCreateGalleryV2Args) => Promise<void>;
+    errorCreateGallery: import("@apollo/client").ApolloError | undefined;
+};
+export { useCreateGalleryV2 };

package/build/api/server-galleries/mutations/useCreateGallery/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateGalleryV2 = void 0;
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useCreateGalleryV2 = () => {
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.galleriesSchema.CreateGalleryV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+    });
+    return { createGallery, errorCreateGallery: error };
+    async function createGallery({ name, description, publicAccessible, creationIds, }) {
+        try {
+            await mutate({
+                variables: { name, description, publicAccessible, creationIds },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useCreateGalleryV2 = useCreateGalleryV2;

package/build/api/server-galleries/mutations/useDeleteGallery/index.d.ts

@@ -0,0 +1,8 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+declare const useDeleteGallery: () => {
+    deleteGallery: ({ galleryId, }: schema.IDeleteGalleryMutationVariables) => Promise<{
+        isSuccess: boolean;
+    }>;
+    errorDelete: import("@apollo/client").ApolloError | undefined;
+};
+export default useDeleteGallery;

package/build/api/server-galleries/mutations/useDeleteGallery/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 ui_1 = require("@/store/ui");
+const useDeleteGallery = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.galleriesSchema.DeleteGalleryDocument, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        onCompleted: (res) => {
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'Gallery successfully deleted!',
+                text: '',
+            });
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, gallery deletion failed.',
+            });
+        },
+    });
+    return { deleteGallery, errorDelete: error };
+    async function deleteGallery({ galleryId, }) {
+        try {
+            const { data } = await mutate({
+                variables: { galleryId },
+            });
+            return { isSuccess: data.deleteGallery };
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useDeleteGallery;

package/build/api/server-galleries/mutations/useDeleteGalleryBanner/index.d.ts

@@ -0,0 +1,5 @@
+import { mediasSchema as schema } from '@ludo.ninja/api';
+export declare const useDeleteGalleryBanner: () => {
+    deleteBanner: ({ galleryId, }: schema.IMutationDeleteGalleryBannerArgs) => Promise<void>;
+    error: import("@apollo/client").ApolloError | undefined;
+};

package/build/api/server-galleries/mutations/useDeleteGalleryBanner/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeleteGalleryBanner = void 0;
+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 ui_1 = require("@/store/ui");
+const useDeleteGalleryBanner = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.mediasSchema.DeleteGalleryBannerDocument, {
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: () => {
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'Banner successfully removed!',
+                text: '',
+            });
+        },
+        // onCompleted: (res) => {
+        //   console.log(res);
+        // },
+        // onError: (err) => console.log(err),
+    });
+    return { deleteBanner, error };
+    async function deleteBanner({ galleryId, }) {
+        try {
+            await mutate({
+                variables: { galleryId },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useDeleteGalleryBanner = useDeleteGalleryBanner;

package/build/api/server-galleries/mutations/useEditGallery/index.d.ts

@@ -0,0 +1,5 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+declare const useEditGallery: () => {
+    editGallery: ({ galleryId, name, description, }: schema.IEditGalleryMutationVariables) => Promise<import("@apollo/client").FetchResult<any>>;
+};
+export default useEditGallery;

package/build/api/server-galleries/mutations/useEditGallery/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useEditGallery = () => {
+    const [mutate] = (0, client_1.useMutation)(api_1.galleriesSchema.EditGalleryDocument, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        // refetchQueries: [
+        //   schema.FetchUserFavoritesDocument,
+        //   schema.FetchUserGalleriesDocument,
+        // ],
+    });
+    async function editGallery({ galleryId, name, description, }) {
+        return mutate({
+            variables: { name, description, galleryId },
+        });
+    }
+    return { editGallery };
+};
+exports.default = useEditGallery;

package/build/api/server-galleries/mutations/useRemoveAssetFromGallery/index.d.ts

@@ -0,0 +1,7 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+declare const useRemoveAssetFromGalleryV2: () => {
+    removeAssetFromGallery: ({ galleryId, assetId, }: schema.IMutationRemoveAssetFromGalleryV2Args) => Promise<void>;
+    errorRemoveAsset: import("@apollo/client").ApolloError | undefined;
+    isAssetRemoved: boolean;
+};
+export { useRemoveAssetFromGalleryV2 };

package/build/api/server-galleries/mutations/useRemoveAssetFromGallery/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRemoveAssetFromGalleryV2 = void 0;
+const react_1 = require("react");
+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 ui_1 = require("@/store/ui");
+const useRemoveAssetFromGalleryV2 = () => {
+    const [isRemoved, setRemove] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.galleriesSchema.RemoveAssetFromGalleryV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ removeAssetFromGalleryV2 }) => {
+            setRemove(removeAssetFromGalleryV2);
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'NFT successfully removed!',
+                text: '',
+            });
+        },
+        refetchQueries: [api_1.galleriesSchema.FetchUserGalleriesV2Document],
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+        },
+    });
+    return {
+        removeAssetFromGallery,
+        errorRemoveAsset: error,
+        isAssetRemoved: isRemoved,
+    };
+    async function removeAssetFromGallery({ galleryId, assetId, }) {
+        try {
+            await mutate({
+                variables: { galleryId, assetId },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useRemoveAssetFromGalleryV2 = useRemoveAssetFromGalleryV2;

package/build/api/server-galleries/mutations/useRemoveCollectionFromGallery/index.d.ts

@@ -0,0 +1,7 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+declare const useRemoveCollectionFromGalleryV2: () => {
+    removeCollectionFromGallery: ({ galleryId, collectionId, }: schema.IMutationRemoveCollectionFromGalleryV2Args) => Promise<void>;
+    errorRemoveCollection: import("@apollo/client").ApolloError | undefined;
+    isCollectionRemoved: boolean;
+};
+export { useRemoveCollectionFromGalleryV2 };

package/build/api/server-galleries/mutations/useRemoveCollectionFromGallery/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRemoveCollectionFromGalleryV2 = void 0;
+const react_1 = require("react");
+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 ui_1 = require("@/store/ui");
+const useRemoveCollectionFromGalleryV2 = () => {
+    const [isRemoved, setRemove] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.galleriesSchema.RemoveCollectionFromGalleryV2Document, {
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ removeCollectionFromGallery }) => {
+            setRemove(removeCollectionFromGallery);
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'Collection successfully removed!',
+                text: '',
+            });
+        },
+        refetchQueries: [api_1.galleriesSchema.FetchUserGalleriesV2Document],
+        // onError: (err) => console.log(err),
+    });
+    return {
+        removeCollectionFromGallery,
+        errorRemoveCollection: error,
+        isCollectionRemoved: isRemoved,
+    };
+    async function removeCollectionFromGallery({ galleryId, collectionId, }) {
+        try {
+            await mutate({
+                variables: { galleryId, collectionId },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.useRemoveCollectionFromGalleryV2 = useRemoveCollectionFromGalleryV2;

package/build/api/server-galleries/queries/useFetchGallery/index.d.ts

@@ -0,0 +1,16 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+import GalleryEntityV2 from '@/dto/GalleryEntityV2';
+declare const prefetchGalleryV2: ({ galleryId }: schema.IQueryFetchGalleryV2Args, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchGalleryV2: null;
+    };
+}>;
+declare const useFetchGalleryV2: ({ galleryId, }: {
+    galleryId: schema.IQueryFetchGalleryV2Args;
+}) => {
+    clientDataLoading: boolean;
+    clientDataError: import("@apollo/client").ApolloError | undefined;
+    clientData: GalleryEntityV2 | null;
+};
+export { prefetchGalleryV2, useFetchGalleryV2 };

package/build/api/server-galleries/queries/useFetchGallery/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchGalleryV2 = exports.prefetchGalleryV2 = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const GalleryEntityV2_1 = __importDefault(require("@/dto/GalleryEntityV2"));
+const prefetchGalleryV2 = ({ galleryId }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.galleriesSchema.FetchGalleryV2Document,
+        variables: { galleryId },
+        context: { uri: api_1.hosts.serverGalleriesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchGalleryV2: null },
+        };
+    });
+};
+exports.prefetchGalleryV2 = prefetchGalleryV2;
+const useFetchGalleryV2 = ({ galleryId, }) => {
+    const [gallery, setGallery] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.galleriesSchema.FetchGalleryV2Document, {
+        variables: { galleryId },
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        onCompleted: ({ fetchGalleryV2 }) => {
+            setGallery(new GalleryEntityV2_1.default(fetchGalleryV2));
+        },
+        onError: () => {
+            setGallery(null);
+        },
+    });
+    return {
+        clientDataLoading: loading,
+        clientDataError: error,
+        clientData: gallery,
+    };
+};
+exports.useFetchGalleryV2 = useFetchGalleryV2;

package/build/api/server-galleries/queries/useFetchGalleryAssets/index.d.ts

@@ -0,0 +1,18 @@
+export declare const FETCH_GALLERY_ASSETS_QUERY: import("@apollo/client").DocumentNode;
+declare const useFetchGalleryAssets: (galleryId: string, pageSize: number) => {
+    loadMore: (pageToken: string) => Promise<void>;
+    refetchGalleryAssetsQuery: {
+        query: import("@apollo/client").DocumentNode;
+        variables: {
+            galleryId: string;
+            pageSize: number;
+        };
+        context: {
+            uri: string;
+        };
+    };
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    data: any;
+};
+export default useFetchGalleryAssets;

package/build/api/server-galleries/queries/useFetchGalleryAssets/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FETCH_GALLERY_ASSETS_QUERY = void 0;
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+exports.FETCH_GALLERY_ASSETS_QUERY = (0, client_1.gql) `
+  query FetchGalleryAssets(
+    $galleryId: String!
+    $pageSize: Int!
+    $pageToken: String
+  ) {
+    fetchGalleryAssets(
+      galleryId: $galleryId
+      pageSize: $pageSize
+      pageToken: $pageToken
+    ) {
+      nextPageToken
+      assets {
+        assetId
+        blockchain
+        name
+        media
+        sizeRatio
+        mimeType
+        likes
+        liked
+        visible
+        blurred
+        createdAt
+      }
+    }
+  }
+`;
+const useFetchGalleryAssets = (galleryId, pageSize) => {
+    const { data, error, loading, fetchMore, networkStatus } = (0, client_1.useQuery)(exports.FETCH_GALLERY_ASSETS_QUERY, {
+        // client: getApolloClient(),
+        variables: {
+            galleryId,
+            pageSize,
+        },
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        notifyOnNetworkStatusChange: true,
+    });
+    const loadingMorePosts = networkStatus === client_1.NetworkStatus.fetchMore;
+    const refetchGalleryAssetsQuery = {
+        query: exports.FETCH_GALLERY_ASSETS_QUERY,
+        variables: { galleryId, pageSize },
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+    };
+    return {
+        loadMore,
+        refetchGalleryAssetsQuery,
+        loading: loading || loadingMorePosts,
+        error,
+        data,
+    };
+    async function loadMore(pageToken) {
+        if (!pageToken)
+            return;
+        await fetchMore({
+            variables: { galleryId, pageSize, pageToken },
+            updateQuery: (prev, { fetchMoreResult }) => {
+                if (!fetchMoreResult)
+                    return prev;
+                const { nextPageToken, assets: nextAssets } = fetchMoreResult.fetchGalleryAssets;
+                if (prev !== null && prev.hasOwnProperty('fetchGalleryAssets')) {
+                    const { assets: prevAssets } = prev.fetchGalleryAssets;
+                    const ids = new Set(prevAssets.map((asset) => asset.id));
+                    const newAssets = [
+                        ...prevAssets,
+                        ...nextAssets.filter((asset) => !ids.has(asset.id)),
+                    ];
+                    return { fetchGalleryAssets: { assets: newAssets, nextPageToken } };
+                }
+                else {
+                    return { fetchGalleryAssets: { assets: nextAssets, nextPageToken } };
+                }
+            },
+        });
+    }
+};
+exports.default = useFetchGalleryAssets;

package/build/api/server-galleries/queries/useFetchMyFavorites/index.d.ts

@@ -0,0 +1,10 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+import GalleryEntityV2 from '@/dto/GalleryEntityV2';
+declare const useFetchMyFavoritesV2: () => {
+    galleryItems: GalleryEntityV2[];
+    isNextLoading: boolean;
+    loadMore: () => Promise<void>;
+    load: ({ pageSize, pageToken }: schema.IQueryFetchMyFavoritesV2Args) => void;
+    isLoading: boolean;
+};
+export { useFetchMyFavoritesV2 };

package/build/api/server-galleries/queries/useFetchMyFavorites/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchMyFavoritesV2 = void 0;
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const GalleryEntityV2_1 = __importDefault(require("@/dto/GalleryEntityV2"));
+const maxUserFavoritesLength = 1000;
+const useFetchMyFavoritesV2 = () => {
+    const [favorites, setFavorites] = (0, react_1.useState)([]);
+    const nextPageTokenRef = (0, react_1.useRef)(null);
+    const [isNextLoading, setIsNextLoading] = (0, react_1.useState)(false);
+    const [fetchMyFavoritesV2, { loading, /*refetch*/ fetchMore }] = api_1.galleriesSchema.useFetchMyFavoritesV2LazyQuery({
+        context: {
+            uri: api_1.hosts.galleriesHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: (data) => {
+            const { fetchMyFavoritesV2: { galleries, nextPageToken }, } = data;
+            if (galleries) {
+                nextPageTokenRef.current = nextPageToken || null;
+                setFavorites(galleries.map((gallery) => new GalleryEntityV2_1.default(gallery)));
+            }
+        },
+        onError: () => {
+            nextPageTokenRef.current = null;
+            setFavorites([]);
+        },
+    });
+    function load({ pageSize, pageToken }) {
+        fetchMyFavoritesV2({
+            variables: { pageSize, pageToken },
+        });
+    }
+    // async function refetchQuery() {
+    //   await refetch();
+    // }
+    async function loadMore() {
+        const pageToken = nextPageTokenRef.current;
+        if (!pageToken || favorites.length >= maxUserFavoritesLength || loading)
+            return;
+        setIsNextLoading(true);
+        try {
+            const { data } = await fetchMore({
+                variables: { pageToken },
+            });
+            const { galleries, nextPageToken } = data.fetchMyFavoritesV2;
+            if (galleries) {
+                nextPageTokenRef.current = nextPageToken || null;
+                setFavorites((prev) => [
+                    ...prev,
+                    ...galleries.map((gallery) => new GalleryEntityV2_1.default(gallery)),
+                ]);
+            }
+        }
+        finally {
+            setIsNextLoading(false);
+        }
+    }
+    return {
+        galleryItems: favorites,
+        isNextLoading,
+        loadMore,
+        load,
+        isLoading: loading,
+    };
+};
+exports.useFetchMyFavoritesV2 = useFetchMyFavoritesV2;

package/build/api/server-galleries/queries/useFetchMyGalleries/index.d.ts

@@ -0,0 +1,10 @@
+import { galleriesSchema as schema } from '@ludo.ninja/api';
+import GalleryEntityV2 from '@/dto/GalleryEntityV2';
+declare const useFetchMyGalleriesV2: () => {
+    galleryItems: GalleryEntityV2[];
+    isNextLoading: boolean;
+    loadMore: () => Promise<void>;
+    load: ({ pageSize, pageToken }: schema.IQueryFetchMyGalleriesV2Args) => void;
+    isLoading: boolean;
+};
+export { useFetchMyGalleriesV2 };