@ludo.ninja/components 2.0.1 → 2.0.2

package/build/api/graphql/index.d.ts

@@ -0,0 +1,4 @@
+import { AppProps } from 'next/app';
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+export declare const APOLLO_STATE_PROP_NAME = "__APOLLO_STATE__";
+export declare function addApolloState(client: ApolloClient<NormalizedCacheObject>, pageProps: AppProps['pageProps']): any;

package/build/api/graphql/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addApolloState = exports.APOLLO_STATE_PROP_NAME = void 0;
+exports.APOLLO_STATE_PROP_NAME = '__APOLLO_STATE__';
+function addApolloState(client, pageProps) {
+    if (pageProps?.props) {
+        pageProps.props[exports.APOLLO_STATE_PROP_NAME] = client.cache.extract();
+    }
+    return pageProps;
+}
+exports.addApolloState = addApolloState;

package/build/api/server-assets/mutations/useDislikeAsset/index.d.ts

@@ -0,0 +1,7 @@
+import { assetSchema as schema } from '@ludo.ninja/api';
+declare const useDisLikeAsset: () => {
+    dislikeAsset: ({ assetId }: schema.IMutationDislikeAssetArgs) => Promise<void>;
+    errorDislikeAsset: import("@apollo/client").ApolloError | undefined;
+    isDisLiked: boolean;
+};
+export default useDisLikeAsset;

package/build/api/server-assets/mutations/useDislikeAsset/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useDisLikeAsset = () => {
+    const [isDisLiked, setDisLiked] = (0, react_1.useState)(false);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.assetSchema.DislikeAssetDocument, {
+        context: {
+            uri: api_1.hosts.assetsHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ dislikeAsset }) => {
+            setDisLiked(dislikeAsset);
+        },
+        onError: () => {
+            setDisLiked(false);
+        },
+    });
+    return { dislikeAsset, errorDislikeAsset: error, isDisLiked };
+    async function dislikeAsset({ assetId }) {
+        try {
+            await mutate({
+                variables: { assetId },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useDisLikeAsset;

package/build/api/server-assets/mutations/useLikeAsset/index.d.ts

@@ -0,0 +1,7 @@
+import { assetSchema as schema } from '@ludo.ninja/api';
+declare const useLikeAsset: () => {
+    likeAsset: ({ assetId }: schema.IMutationLikeAssetArgs) => Promise<void>;
+    errorLikeAsset: import("@apollo/client").ApolloError | undefined;
+    isLiked: boolean;
+};
+export default useLikeAsset;

package/build/api/server-assets/mutations/useLikeAsset/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useLikeAsset = () => {
+    const [isLiked, setLike] = (0, react_1.useState)(false);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.assetSchema.LikeAssetDocument, {
+        context: {
+            uri: api_1.hosts.assetsHost,
+        },
+        fetchPolicy: 'no-cache',
+        // refetchQueries: [schema.FetchLikedDocument],
+        onCompleted: ({ likeAsset }) => {
+            setLike(likeAsset);
+        },
+        onError: () => {
+            setLike(false);
+        },
+    });
+    return { likeAsset, errorLikeAsset: error, isLiked };
+    async function likeAsset({ assetId }) {
+        try {
+            await mutate({
+                variables: { assetId },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useLikeAsset;

package/build/api/server-assets/queries/useFetchAssetByBlockchain/index.d.ts

@@ -0,0 +1,14 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { searchSchema as schema } from '@ludo.ninja/api';
+import AssetEntity from '@/dto/AssetEntity';
+declare const prefetchAssetByBlockchain: ({ blockchain, address, elrondId, tokenId, }: schema.IQueryFetchAssetByBlockchainArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchAssetByBlockchain: null;
+    };
+}>;
+declare const useFetchAssetByBlockchain: ({ blockchain, address, elrondId, tokenId, }: schema.IQueryFetchAssetByBlockchainArgs, prefetchedAsset: AssetEntity | null) => {
+    clientData: AssetEntity | null;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export { prefetchAssetByBlockchain, useFetchAssetByBlockchain };

package/build/api/server-assets/queries/useFetchAssetByBlockchain/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchAssetByBlockchain = exports.prefetchAssetByBlockchain = void 0;
+const react_1 = require("react");
+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 AssetEntity_1 = __importDefault(require("@/dto/AssetEntity"));
+const prefetchAssetByBlockchain = async ({ blockchain, address, elrondId, tokenId, }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.searchSchema.FetchAssetByBlockchainDocument,
+        variables: { blockchain, address, elrondId, tokenId },
+        context: { uri: api_1.hosts.serverSearchHost }, // faster service assets for production,
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchAssetByBlockchain: null },
+        };
+    });
+};
+exports.prefetchAssetByBlockchain = prefetchAssetByBlockchain;
+const useFetchAssetByBlockchain = ({ blockchain, address, elrondId, tokenId, }, prefetchedAsset) => {
+    const [asset, setAsset] = (0, react_1.useState)(prefetchedAsset);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { loading, error } = api_1.searchSchema.useFetchAssetByBlockchainQuery({
+        variables: { blockchain, address, elrondId, tokenId },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        onCompleted: ({ fetchAssetByBlockchain }) => {
+            setAsset(new AssetEntity_1.default(fetchAssetByBlockchain));
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            setAsset(null);
+        },
+    });
+    return { clientData: asset, loading, error };
+};
+exports.useFetchAssetByBlockchain = useFetchAssetByBlockchain;

package/build/api/server-assets/queries/useFetchAssets/index.d.ts

@@ -0,0 +1,7 @@
+import { searchSchema as schema } from '@ludo.ninja/api';
+declare const useFetchAssetsByIds: ({ assetIds }: schema.IQueryFetchAssetsArgs) => (import("@apollo/client").LazyQueryExecFunction<any, import("@apollo/client").OperationVariables> | {
+    clientData: schema.IAsset | null;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+})[];
+export { useFetchAssetsByIds };

package/build/api/server-assets/queries/useFetchAssets/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchAssetsByIds = 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 useFetchAssetsByIds = ({ assetIds }) => {
+    const [assets, setAsset] = (0, react_1.useState)(null);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [getAssets, { loading, error }] = (0, client_1.useLazyQuery)(api_1.searchSchema.FetchAssetsDocument, {
+        variables: { assetIds },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: 'cache-first',
+        onCompleted: ({ fetchAssets: data }) => {
+            setAsset(data);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            setAsset(null);
+        },
+    });
+    return [getAssets, { clientData: assets, loading, error }];
+};
+exports.useFetchAssetsByIds = useFetchAssetsByIds;

package/build/api/server-assets/queries/useFetchDynamicAssetLikes/index.d.ts

@@ -0,0 +1,8 @@
+import { searchSchema as schema } from '@ludo.ninja/api';
+declare const useFetchDynamicAssetLikes: ({ assetId, }: schema.IQueryFetchDynamicAssetDataArgs) => {
+    likesByUser: number;
+    isLikedByUser: boolean;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useFetchDynamicAssetLikes;

package/build/api/server-assets/queries/useFetchDynamicAssetLikes/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 useFetchDynamicAssetLikes = ({ assetId, }) => {
+    const [isLikedByUser, setLikedByUser] = (0, react_1.useState)(false);
+    const [likesByUser, setLikesByUser] = (0, react_1.useState)(0);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { error } = (0, client_1.useQuery)(api_1.searchSchema.FetchDynamicAssetLikesDocument, {
+        variables: { assetId },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ fetchDynamicAssetData: data }) => {
+            setLikedByUser(data.isLikedByUser ? data.isLikedByUser : false);
+            setLikesByUser(data.likesNum);
+            setLoading(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            setLikedByUser(false);
+            setLoading(false);
+        },
+    });
+    return { likesByUser, isLikedByUser, loading, error };
+};
+exports.default = useFetchDynamicAssetLikes;

package/build/api/server-assets/queries/useFetchDynamicAssetsLikes/index.d.ts

@@ -0,0 +1,7 @@
+import { searchSchema as schema } from '@ludo.ninja/api';
+declare const useFetchDynamicAssetsLikes: ({ assetIds, }: schema.IQueryFetchDynamicAssetsDataArgs) => {
+    infoAssetsLikes: schema.IDynamicAssetData[] | null;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useFetchDynamicAssetsLikes;

package/build/api/server-assets/queries/useFetchDynamicAssetsLikes/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 useFetchDynamicAssetsLikes = ({ assetIds, }) => {
+    const [infoAssetsLikes, setInfoAssetsLikes] = (0, react_1.useState)(null);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { loading, error } = (0, client_1.useQuery)(api_1.searchSchema.FetchDynamicAssetsLikesDocument, {
+        variables: { assetIds },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: ({ fetchDynamicAssetsData: data }) => {
+            setInfoAssetsLikes(data);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            setInfoAssetsLikes(null);
+        },
+    });
+    return { infoAssetsLikes, loading, error };
+};
+exports.default = useFetchDynamicAssetsLikes;

package/build/api/server-collection/mutations/useDislikeCollection/index.d.ts

@@ -0,0 +1,7 @@
+import { collectionsSchema as schema } from '@ludo.ninja/api';
+declare const useDislikeCollection: () => {
+    dislikeCollection: ({ collectionId, }: schema.IMutationDislikeCollectionArgs) => Promise<void>;
+    errorDislikeCollection: import("@apollo/client").ApolloError | undefined;
+    isDisLiked: boolean;
+};
+export default useDislikeCollection;

package/build/api/server-collection/mutations/useDislikeCollection/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useDislikeCollection = () => {
+    const [isDisLiked, setDisLiked] = (0, react_1.useState)(false);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.collectionsSchema.DislikeCollectionDocument, {
+        context: {
+            uri: api_1.hosts.collectionsHost,
+        },
+        onCompleted: ({ dislikeCollection }) => {
+            setDisLiked(dislikeCollection);
+        },
+        onError: () => {
+            setDisLiked(false);
+        },
+    });
+    return { dislikeCollection, errorDislikeCollection: error, isDisLiked };
+    async function dislikeCollection({ collectionId, }) {
+        try {
+            await mutate({
+                variables: { collectionId },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useDislikeCollection;

package/build/api/server-collection/mutations/useLikeCollection/index.d.ts

@@ -0,0 +1,7 @@
+import { collectionsSchema as schema } from '@ludo.ninja/api';
+declare const useLikeCollection: () => {
+    likeCollection: ({ collectionId, }: schema.IMutationLikeCollectionArgs) => Promise<void>;
+    errorLikeCollection: import("@apollo/client").ApolloError | undefined;
+    isLiked: boolean;
+};
+export default useLikeCollection;

package/build/api/server-collection/mutations/useLikeCollection/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useLikeCollection = () => {
+    const [isLiked, setLike] = (0, react_1.useState)(false);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.collectionsSchema.LikeCollectionDocument, {
+        context: {
+            uri: api_1.hosts.collectionsHost,
+        },
+        onCompleted: ({ likeCollection }) => {
+            setLike(likeCollection);
+        },
+        onError: () => {
+            setLike(false);
+        },
+    });
+    return { likeCollection, errorLikeCollection: error, isLiked };
+    async function likeCollection({ collectionId, }) {
+        try {
+            await mutate({
+                variables: { collectionId },
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+};
+exports.default = useLikeCollection;

package/build/api/server-experiences/queries/useFetchMyExperienceWithLevel/index.d.ts

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

package/build/api/server-experiences/queries/useFetchMyExperienceWithLevel/index.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const router_1 = require("next/router");
+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 store_1 = require("@/modules/user/store");
+const ui_1 = require("@/store/ui");
+const notifications_1 = require("@/modules/notifications");
+const useFetchMyExperienceWithLevel = () => {
+    const { user, isSignedIn, setUserExp, resetUserExp, setErrorExp, setIsLoadingExp, } = (0, store_1.useUserStore)((state) => ({
+        user: state.user,
+        isSignedIn: state.isSignedIn,
+        setUserExp: state.setUserExp,
+        resetUserExp: state.resetUserExp,
+        setErrorExp: state.setErrorExp,
+        setIsLoadingExp: state.setIsLoadingExp,
+    }));
+    const { openAlert, addNotification } = (0, ui_1.useUiStore)((state) => ({
+        openAlert: state.openAlert,
+        addNotification: state.addNotification,
+    }));
+    const router = (0, router_1.useRouter)();
+    const userId = user?.userId || '';
+    const [fetchExp, { subscribeToMore }] = (0, client_1.useLazyQuery)(api_1.experiencesSchema.FetchMyExperienceV2Document, {
+        context: {
+            uri: api_1.hosts.experiencesHost,
+        },
+        onCompleted: ({ fetchMyExperienceV2: { xps, level, levelMaxXps, levelMinXps }, }) => {
+            setIsLoadingExp(false);
+            setUserExp({
+                xps,
+                level,
+                levelMaxXps,
+                levelMinXps,
+            });
+            subscribe();
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            resetUserExp();
+            setErrorExp(err);
+            setIsLoadingExp(false);
+        },
+    });
+    const subscribe = () => {
+        const { authToken } = api_1.authCookies.getCookies();
+        subscribeToMore({
+            variables: { authToken },
+            document: api_1.experiencesSchema.OnMyExperienceIncrementedDocument,
+            updateQuery: (prev, { subscriptionData: { data } }) => {
+                if (!data)
+                    return prev;
+                const { xps, level, levelMaxXps, levelMinXps, xpsIncrement, description, } = data.onMyExperienceIncremented;
+                if (xpsIncrement) {
+                    addNotification((0, notifications_1.createXpNotification)({
+                        xpsIncrement,
+                        ...(description ? { description } : {}),
+                        onClick: () => {
+                            router.push(`/rewards/${userId}`);
+                        },
+                    }));
+                }
+                setUserExp({
+                    xps,
+                    level,
+                    levelMaxXps,
+                    levelMinXps,
+                });
+            },
+        });
+    };
+    (0, react_1.useEffect)(() => {
+        if (isSignedIn) {
+            setIsLoadingExp(true);
+            fetchExp();
+        }
+    }, [isSignedIn]);
+};
+exports.default = useFetchMyExperienceWithLevel;

package/build/api/server-experiences/queries/useFetchMyTasks/index.d.ts

@@ -0,0 +1,31 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { experiencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchMyTasks: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchMyTasks: null;
+    };
+}>;
+export declare const useFetchMyTasks: ({ prefetchedMyTasks, }: {
+    prefetchedMyTasks: schema.ITask[] | null;
+}) => {
+    loadingMyTasks: boolean;
+    errorMyTasks: import("@apollo/client").ApolloError | undefined;
+    data: any;
+    clientMyTasksData: schema.ITask[] | null;
+};
+declare const _default: {
+    useFetchMyTasks: ({ prefetchedMyTasks, }: {
+        prefetchedMyTasks: schema.ITask[] | null;
+    }) => {
+        loadingMyTasks: boolean;
+        errorMyTasks: import("@apollo/client").ApolloError | undefined;
+        data: any;
+        clientMyTasksData: schema.ITask[] | null;
+    };
+    prefetchMyTasks: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+        data: {
+            fetchMyTasks: null;
+        };
+    }>;
+};
+export default _default;

package/build/api/server-experiences/queries/useFetchMyTasks/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchMyTasks = exports.prefetchMyTasks = 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 prefetchMyTasks = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.experiencesSchema.FetchMyTasksDocument,
+        context: { uri: api_1.hosts.serverExperiencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchMyTasks: null },
+        };
+    });
+};
+exports.prefetchMyTasks = prefetchMyTasks;
+const useFetchMyTasks = ({ prefetchedMyTasks, }) => {
+    const [myTasks, setMyTasks] = (0, react_1.useState)(prefetchedMyTasks);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { data, error, loading } = (0, client_1.useQuery)(api_1.experiencesSchema.FetchMyTasksDocument, {
+        context: {
+            uri: api_1.hosts.experiencesHost,
+        },
+        onCompleted: ({ fetchMyTasks }) => {
+            setMyTasks(fetchMyTasks);
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            setMyTasks([]);
+        },
+    });
+    return {
+        loadingMyTasks: loading,
+        errorMyTasks: error,
+        data,
+        clientMyTasksData: myTasks,
+    };
+};
+exports.useFetchMyTasks = useFetchMyTasks;
+exports.default = { useFetchMyTasks: exports.useFetchMyTasks, prefetchMyTasks: exports.prefetchMyTasks };

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

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

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

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

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

@@ -0,0 +1,4 @@
+import { mediasSchema as schema } from '@ludo.ninja/api';
+export declare const useAddChangeGalleryBanner: () => {
+    addBanner: ({ galleryId, file, }: schema.IMutationUploadGalleryBannerArgs) => Promise<import("@apollo/client").FetchResult<any>>;
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAddChangeGalleryBanner = 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 useAddChangeGalleryBanner = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = (0, client_1.useMutation)(api_1.mediasSchema.UploadGalleryBannerDocument, {
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        fetchPolicy: 'no-cache',
+        onCompleted: () => {
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'Banner successfully added!',
+                text: '',
+            });
+        },
+    });
+    async function addBanner({ galleryId, file, }) {
+        return mutate({
+            variables: { galleryId, file },
+        });
+    }
+    return { addBanner };
+};
+exports.useAddChangeGalleryBanner = useAddChangeGalleryBanner;

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

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