@ludo.ninja/components 2.3.6 → 2.3.7

package/build/api/server-search/queries/useFetchAllCreations/index.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchAllCreations = exports.prefetchAllCreations = void 0;
+const builder_1 = require("../../../../entities/creation/builder");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const react_1 = require("react");
+const prefetchAllCreations = ({ page }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.searchSchema.FetchAllCreationsDocument,
+        variables: {
+            page,
+        },
+        context: { uri: api_1.hosts.serverSearchHost },
+        fetchPolicy: "network-only",
+    })
+        .catch(() => {
+        return {
+            data: { fetchAllCreations: null },
+        };
+    });
+};
+exports.prefetchAllCreations = prefetchAllCreations;
+const maxCreationLength = 1000;
+const useFetchAllCreations = ({ page }) => {
+    const [allCreations, setCreations] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const { error, loading, fetchMore, networkStatus, refetch } = api_1.searchSchema.useFetchAllCreationsQuery({
+        variables: {
+            page,
+        },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        onCompleted: ({ fetchAllCreations }) => {
+            setCreations(fetchAllCreations.creations.map((creation) => (0, builder_1.buildCreation)(creation)));
+            setNextPageToken(fetchAllCreations.nextPage?.token || null);
+        },
+        onError: () => {
+            setCreations([]);
+            setNextPageToken(null);
+        },
+    });
+    const loadingMoreCreations = networkStatus === client_1.NetworkStatus.fetchMore;
+    return {
+        loadMore,
+        loading: loading || loadingMoreCreations,
+        refetchQuery,
+        error,
+        allCreations,
+        nextPageToken,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || allCreations.length >= maxCreationLength)
+            return;
+        await fetchMore({
+            variables: {
+                page: {
+                    token: pageToken,
+                    ...(page && "size" in page ? { size: page.size } : {}),
+                },
+            },
+            updateQuery: (prev, { fetchMoreResult }) => {
+                if (!fetchMoreResult)
+                    return prev;
+                const { creations: nextCreations, ...response } = fetchMoreResult.fetchAllCreations;
+                if (prev !== null && prev.hasOwnProperty("fetchAllCreations")) {
+                    const { creations: prevCreations } = prev.fetchAllCreations;
+                    return {
+                        fetchAllCreations: {
+                            creations: [...prevCreations, ...nextCreations],
+                            ...response,
+                        },
+                    };
+                }
+                else {
+                    refetchQuery();
+                    return {
+                        fetchAllCreations: { creations: nextCreations, ...response },
+                    };
+                }
+            },
+        });
+    }
+};
+exports.useFetchAllCreations = useFetchAllCreations;
+exports.default = { useFetchAllCreations: exports.useFetchAllCreations, prefetchAllCreations: exports.prefetchAllCreations };

package/build/api/server-search/queries/useFetchAssetsCount/index.d.ts

@@ -0,0 +1,7 @@
+declare const useFetchNftCount: () => {
+    loading: boolean;
+    error: null;
+    data: null;
+    count: number;
+};
+export default useFetchNftCount;

package/build/api/server-search/queries/useFetchAssetsCount/index.js

@@ -0,0 +1,33 @@
+"use strict";
+// import { useState } from 'react';
+//
+// import { useQuery } from '@apollo/client';
+//
+// import { hosts, searchSchema as schema } from '@ludo.ninja/api';
+// import { alertVariants } from '@ludo.ninja/ui/build/system/Alert/type';
+//
+// import { useUiStore } from '@/store/ui';
+Object.defineProperty(exports, "__esModule", { value: true });
+const useFetchNftCount = () => {
+    // const [count, setCount] = useState<number>(0);
+    // const openAlert = useUiStore((state) => state.openAlert);
+    // const { data, error, loading } = useQuery(schema.FetchAssetsCountDocument, {
+    //   context: {
+    //     uri: hosts.searchHost,
+    //   },
+    //   fetchPolicy: 'no-cache',
+    //   onCompleted: ({ fetchAssetsCount }) => {
+    //     setCount(fetchAssetsCount);
+    //   },
+    //   onError: (err) => {
+    //     openAlert({
+    //       type: alertVariants.error,
+    //
+    //       caption: err.message,
+    //     });
+    //     setCount(0);
+    //   },
+    // });
+    return { loading: true, error: null, data: null, count: 0 };
+};
+exports.default = useFetchNftCount;

package/build/api/server-search/queries/useFetchCollections/index.d.ts

@@ -0,0 +1,23 @@
+import { TCreation } from '../../../../entities/creation/types';
+import { searchSchema as schema } from "@ludo.ninja/api";
+export declare const useFindCollections: ({ term, input, page }: schema.IQueryFindCollectionsArgs) => {
+    loadMore: (pageToken: string) => Promise<void>;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    results: number;
+    collections: TCreation[];
+    nextPageToken: string | null;
+    refetchQuery: () => Promise<void>;
+};
+declare const _default: {
+    useFindCollections: ({ term, input, page }: schema.IQueryFindCollectionsArgs) => {
+        loadMore: (pageToken: string) => Promise<void>;
+        loading: boolean;
+        error: import("@apollo/client").ApolloError | undefined;
+        results: number;
+        collections: TCreation[];
+        nextPageToken: string | null;
+        refetchQuery: () => Promise<void>;
+    };
+};
+export default _default;

package/build/api/server-search/queries/useFetchCollections/index.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFindCollections = void 0;
+const collectionCreationBuilder_1 = require("../../../../entities/creation/collectionCreationBuilder");
+const types_1 = require("../../../../entities/labelCreationType/types");
+const ui_1 = require("../../../../store/ui");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const react_1 = require("react");
+// export const prefetchFindCollections = (
+//   { term, input, pageSize, pageToken }: schema.IQueryFindCollectionsArgs,
+//   apolloClient: ApolloClient<NormalizedCacheObject>
+// ) => {
+//   return apolloClient
+//     .query({
+//       query: schema.FindCollectionsDocument,
+//       variables: { term, input, pageSize, pageToken },
+//       context: { uri: hosts.serverSearchHost },
+//       fetchPolicy: 'network-only',
+//     })
+//     .catch(() => {
+//       return {
+//         data: { findCollections: null },
+//       };
+//     });
+// };
+const maxCollectionsLength = 1000;
+const useFindCollections = ({ term, input, page }) => {
+    const [collections, setCollections] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { error, loading, fetchMore, refetch } = (0, client_1.useQuery)(api_1.searchSchema.FindCollectionsDocument, {
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        variables: { term, input, page },
+        onCompleted: ({ findCollections: { collections, nextPageToken, results } }) => {
+            setCollections(collections.map((collection) => (0, collectionCreationBuilder_1.buildCollectionCreation)({
+                ...collection,
+                name: collection.collectionTitle,
+            }, types_1.LabelKeys.collection)));
+            setResults(results);
+            setNextPageToken(nextPageToken);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+            });
+            setCollections([]);
+            setNextPageToken(null);
+        },
+    });
+    return {
+        loadMore,
+        loading: loading,
+        error,
+        results,
+        collections,
+        nextPageToken,
+        refetchQuery,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || collections.length >= maxCollectionsLength)
+            return;
+        await fetchMore({
+            variables: { pageToken },
+            updateQuery: (prev, { fetchMoreResult }) => {
+                if (!fetchMoreResult)
+                    return prev;
+                const { collections: nextCollections, ...rest } = fetchMoreResult.findCollections;
+                if (prev !== null && prev.hasOwnProperty("findCollections")) {
+                    const { collections: prevCollections } = prev.findCollections;
+                    return {
+                        findCollections: {
+                            collections: [...prevCollections, ...nextCollections],
+                            ...rest,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        findCollections: {
+                            collections: nextCollections,
+                            ...rest,
+                        },
+                    };
+                }
+            },
+        });
+    }
+};
+exports.useFindCollections = useFindCollections;
+exports.default = { /*prefetchFindCollections,*/ useFindCollections: /*prefetchFindCollections,*/ exports.useFindCollections };

package/build/api/server-search/queries/useFetchDynamicCollectionData/index.d.ts

@@ -0,0 +1,13 @@
+import { TCreation } from '../../../../entities/creation/types';
+import { searchSchema as schema } from "@ludo.ninja/api";
+declare const useFetchDynamicCollectionData: ({ input }: schema.IQueryFetchDynamicCollectionDataArgs) => {
+    loadMore: (pageToken: string | null) => Promise<void>;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    refetchQuery: () => Promise<void>;
+    collectionAssetsList: TCreation[];
+    nextPageToken: string | null;
+    likesCount: number;
+    isLikedByUser: boolean;
+};
+export { useFetchDynamicCollectionData };

package/build/api/server-search/queries/useFetchDynamicCollectionData/index.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchDynamicCollectionData = void 0;
+const collectionCreationBuilder_1 = require("../../../../entities/creation/collectionCreationBuilder");
+const ui_1 = require("../../../../store/ui");
+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 react_1 = require("react");
+const maxCollectionListLength = 1000;
+const useFetchDynamicCollectionData = ({ input }) => {
+    const [collectionAssetsList, setCollectionAssetsList] = (0, react_1.useState)([]);
+    const { page, collectionId } = input;
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [likesCount, setLikesCount] = (0, react_1.useState)(0);
+    const [isLikedByUser, setIslikedByUser] = (0, react_1.useState)(false);
+    const { error, loading, fetchMore, networkStatus, refetch } = (0, client_1.useQuery)(api_1.searchSchema.FetchDynamicCollectionDataDocument, {
+        variables: { input },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        onCompleted: ({ fetchDynamicCollectionData: { isLikedByUser, likesNum, collectionAssetsPage: { nextPage, collectionAssets }, }, }) => {
+            setLikesCount(likesNum);
+            setIslikedByUser(isLikedByUser);
+            setNextPageToken(nextPage.token);
+            setCollectionAssetsList(collectionAssets.map((collectionAsset) => (0, collectionCreationBuilder_1.buildCollectionCreation)({
+                ...collectionAsset,
+                collectionId: collectionAsset.assetId,
+            })));
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+            });
+            setCollectionAssetsList([]);
+            setNextPageToken(null);
+        },
+    });
+    const loadingMorePosts = networkStatus === client_1.NetworkStatus.fetchMore;
+    return {
+        loadMore,
+        loading: loading || loadingMorePosts,
+        error,
+        refetchQuery,
+        collectionAssetsList,
+        nextPageToken,
+        likesCount,
+        isLikedByUser,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || collectionAssetsList.length >= maxCollectionListLength)
+            return;
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    input: { page: { token: pageToken, size: page?.size }, collectionId },
+                },
+            });
+            const { collectionAssetsPage: { nextPage, collectionAssets: nextCollectionAssetsList }, } = data.fetchDynamicCollectionData;
+            setCollectionAssetsList((prevCollection) => [
+                ...prevCollection,
+                ...nextCollectionAssetsList.map((collectionAsset) => (0, collectionCreationBuilder_1.buildCollectionCreation)({
+                    ...collectionAsset,
+                    collectionId: collectionAsset.assetId,
+                })),
+            ]);
+            setNextPageToken(nextPage.token);
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    }
+    // await fetchMore({
+    //   variables: {
+    //     input: { assetsPageToken: pageToken, assetsPageSize, collectionId },
+    //   },
+    //   updateQuery: (prev, { fetchMoreResult }) => {
+    //     if (!fetchMoreResult) return prev;
+    //     const {
+    //       collectionAssetsPage: {
+    //         nextPageToken,
+    //         collectionAssets: nextCollectionAssetsList,
+    //       },
+    //     } = fetchMoreResult.fetchDynamicCollectionData;
+    //     if (
+    //       prev !== null &&
+    //       prev.hasOwnProperty('fetchDynamicCollectionData')
+    //     ) {
+    //       const {
+    //         collectionAssetsPage: {
+    //           collectionAssets: prevCollectionAssetsList,
+    //         },
+    //       } = prev.fetchDynamicCollectionData;
+    //       const updatedCollectionAssetsList = prevCollectionAssetsList.concat(
+    //         nextCollectionAssetsList
+    //       );
+    //       return {
+    //         fetchDynamicCollectionData: {
+    //           collectionAssetsPage: {
+    //             nextPageToken,
+    //             collectionAssets: updatedCollectionAssetsList,
+    //           },
+    //         },
+    //       };
+    //     } else {
+    //       return {
+    //         fetchDynamicCollectionData: {
+    //           collectionAssetsPage: {
+    //             nextPageToken,
+    //             collectionAssets: nextCollectionAssetsList,
+    //           },
+    //         },
+    //       };
+    //     }
+    //   },
+    // });
+};
+exports.useFetchDynamicCollectionData = useFetchDynamicCollectionData;

package/build/api/server-search/queries/useFetchFindAllTopEntitiesByName/index.d.ts

@@ -0,0 +1,47 @@
+import { TAsset } from '../../../../entities/asset/types';
+import { ApolloClient, NormalizedCacheObject } from "@apollo/client";
+import { searchSchema } from "@ludo.ninja/api";
+import { ProfileEntity } from "@ludo.ninja/core";
+export declare const prefetchFindAllTopEntitiesByName: ({ name, pageSize }: searchSchema.IQueryFindAllTopEntitiesByNameArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        findAllTopEntitiesByName: null;
+    };
+}>;
+export declare const useFetchFindAllTopEntitiesByName: () => {
+    data: searchSchema.IFindAllTopEntitiesByNameQuery | undefined;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    load: ({ name, pageSize }: searchSchema.IQueryFindAllTopEntitiesByNameArgs) => Promise<import("@apollo/client").QueryResult<searchSchema.IFindAllTopEntitiesByNameQuery, searchSchema.Exact<{
+        name: string;
+        pageSize: number;
+    }>>>;
+    topEntities: {
+        assets: TAsset[];
+        collections: searchSchema.ICollection[];
+        profiles: ProfileEntity[];
+    } | null;
+    clearTopEntitiesState: () => void;
+};
+declare const _default: {
+    useFetchFindAllTopEntitiesByName: () => {
+        data: searchSchema.IFindAllTopEntitiesByNameQuery | undefined;
+        loading: boolean;
+        error: import("@apollo/client").ApolloError | undefined;
+        load: ({ name, pageSize }: searchSchema.IQueryFindAllTopEntitiesByNameArgs) => Promise<import("@apollo/client").QueryResult<searchSchema.IFindAllTopEntitiesByNameQuery, searchSchema.Exact<{
+            name: string;
+            pageSize: number;
+        }>>>;
+        topEntities: {
+            assets: TAsset[];
+            collections: searchSchema.ICollection[];
+            profiles: ProfileEntity[];
+        } | null;
+        clearTopEntitiesState: () => void;
+    };
+    prefetchFindAllTopEntitiesByName: ({ name, pageSize }: searchSchema.IQueryFindAllTopEntitiesByNameArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+        data: {
+            findAllTopEntitiesByName: null;
+        };
+    }>;
+};
+export default _default;

package/build/api/server-search/queries/useFetchFindAllTopEntitiesByName/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchFindAllTopEntitiesByName = exports.prefetchFindAllTopEntitiesByName = void 0;
+const builder_1 = require("../../../../entities/asset/builder");
+const api_1 = require("@ludo.ninja/api");
+const core_1 = require("@ludo.ninja/core");
+const react_1 = require("react");
+const prefetchFindAllTopEntitiesByName = ({ name, pageSize }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.searchSchema.FindAllTopEntitiesByNameDocument,
+        context: { uri: api_1.hosts.serverSearchHost },
+        variables: { name, pageSize },
+        fetchPolicy: "network-only",
+    })
+        .catch(() => {
+        return {
+            data: { findAllTopEntitiesByName: null },
+        };
+    });
+};
+exports.prefetchFindAllTopEntitiesByName = prefetchFindAllTopEntitiesByName;
+const useFetchFindAllTopEntitiesByName = () => {
+    const [topEntities, setTopEntities] = (0, react_1.useState)(null);
+    const [findAllTopEntitiesByName, { data, error, loading }] = api_1.searchSchema.useFindAllTopEntitiesByNameLazyQuery({
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        onCompleted: ({ findAllTopEntitiesByName }) => {
+            const assets = findAllTopEntitiesByName.assets.map((asset) => (0, builder_1.buildAsset)(asset)) || [];
+            const profiles = findAllTopEntitiesByName.profiles.map((profile) => new core_1.ProfileEntity(profile)) || [];
+            setTopEntities({
+                assets,
+                collections: findAllTopEntitiesByName.collections,
+                profiles,
+            });
+        },
+        onError: () => {
+            setTopEntities(null);
+        },
+    });
+    function clearTopEntitiesState() {
+        setTopEntities(null);
+    }
+    function load({ name, pageSize }) {
+        return findAllTopEntitiesByName({
+            variables: { name, pageSize },
+        });
+    }
+    return { data, loading, error, load, topEntities, clearTopEntitiesState };
+};
+exports.useFetchFindAllTopEntitiesByName = useFetchFindAllTopEntitiesByName;
+exports.default = {
+    useFetchFindAllTopEntitiesByName: exports.useFetchFindAllTopEntitiesByName,
+    prefetchFindAllTopEntitiesByName: exports.prefetchFindAllTopEntitiesByName,
+};

package/build/api/server-search/queries/useFetchLudoNftsTonPage/index.d.ts

@@ -0,0 +1,15 @@
+import { TCreation } from '../../../../entities/creation/types';
+import { searchSchema as schema } from "@ludo.ninja/api";
+declare const useFetchLudoNftsTonPage: ({ userId, scrollTab, }: {
+    scrollTab: string | undefined;
+    userId: schema.IQueryFetchLudoNftsTonPageArgs["userId"];
+}) => {
+    isLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    totalResults: number;
+    creations: TCreation[];
+    refetchQuery: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    isNextLoading: boolean;
+};
+export default useFetchLudoNftsTonPage;

package/build/api/server-search/queries/useFetchLudoNftsTonPage/index.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const builder_1 = require("../../../../entities/creation/builder");
+const getPageSizeAssets_1 = require("../../../../utils/getPageSizeAssets");
+const api_1 = require("@ludo.ninja/api");
+const react_1 = require("react");
+const limit = 20;
+const useFetchLudoNftsTonPage = ({ userId, scrollTab, }) => {
+    const [creations, setCreations] = (0, react_1.useState)([]);
+    const nextPageToken = (0, react_1.useRef)(null);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    const [isNextLoading, setIsNextLoading] = (0, react_1.useState)(false);
+    const isHaveNextPage = creations.length < results;
+    const mapLudoNftToCreation = (ludoNftTon) => {
+        const isVideoMediaAvailable = ludoNftTon.originalUrls.length === 2;
+        return {
+            ...ludoNftTon,
+            creationId: ludoNftTon.id,
+            itemId: ludoNftTon.id,
+            itemType: "asset",
+            blockchain: "ton",
+            ...(isVideoMediaAvailable ? { originalUrls: [ludoNftTon.originalUrls[1]], mimeType: "video/mp4" } : {}),
+        };
+    };
+    const [fetchLudoCreations, { error, refetch, fetchMore }] = api_1.searchSchema.useFetchLudoNftsTonPageLazyQuery({
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchLudoNftsTonPage: { ludoNftsTon, ...nextPage } }) => {
+            setCreations(ludoNftsTon.map((ludoNft) => (0, builder_1.buildCreation)(mapLudoNftToCreation(ludoNft))));
+            setResults(nextPage.nextPage?.elements || 0);
+            setIsLoading(false);
+            nextPageToken.current = nextPage.nextPage?.token || null;
+        },
+        onError: () => {
+            setCreations([]);
+            setIsLoading(false);
+            nextPageToken.current = null;
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        setIsLoading(true);
+        fetchLudoCreations({
+            variables: {
+                userId,
+                page: {
+                    size: (0, getPageSizeAssets_1.getPageSize)({
+                        scrollTab,
+                        limit,
+                    }),
+                    token: null,
+                    num: 1,
+                },
+            },
+        });
+    }, [userId]);
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore() {
+        if (!nextPageToken.current || !isHaveNextPage)
+            return;
+        setIsNextLoading(true);
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    userId,
+                    page: {
+                        token: nextPageToken.current,
+                        size: limit,
+                    },
+                },
+                updateQuery: (previousQueryResult) => {
+                    return previousQueryResult;
+                },
+            });
+            const { ludoNftsTon: nextCreations, ...nextPage } = data.fetchLudoNftsTonPage;
+            setCreations((prevCreations) => [
+                ...prevCreations,
+                ...nextCreations.map((ludoNft) => (0, builder_1.buildCreation)(mapLudoNftToCreation(ludoNft))),
+            ]);
+            setResults(nextPage.nextPage?.elements || 0);
+            nextPageToken.current = nextPage.nextPage?.token || null;
+        }
+        catch (error) {
+            //todo uncomment next line
+            // throw new Error(error as string);
+        }
+        finally {
+            setIsNextLoading(false);
+        }
+    }
+    return {
+        isLoading,
+        error,
+        totalResults: results,
+        creations,
+        refetchQuery,
+        loadMore,
+        isNextLoading,
+    };
+};
+exports.default = useFetchLudoNftsTonPage;

package/build/api/server-search/queries/useFetchNetWorth/index.d.ts

@@ -0,0 +1,7 @@
+import { searchSchema as schema } from '@ludo.ninja/api';
+declare const useFetchNetWorth: (ownerId: string) => {
+    response: schema.IProfile | null;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useFetchNetWorth;

package/build/api/server-search/queries/useFetchNetWorth/index.js

@@ -0,0 +1,23 @@
+"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 useFetchNetWorth = (ownerId) => {
+    const [response, setResponse] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.searchSchema.FetchUserPortfolioDocument, {
+        variables: { ownerId },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        notifyOnNetworkStatusChange: true,
+        onCompleted: ({ fetchUserPortfolio }) => {
+            setResponse(fetchUserPortfolio);
+        },
+        onError: () => {
+            setResponse(null);
+        },
+    });
+    return { response, loading, error };
+};
+exports.default = useFetchNetWorth;