@ludo.ninja/components 2.0.1 → 2.0.2

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

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchAllCreations = exports.prefetchAllCreations = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const CreationEntity_1 = __importDefault(require("@/dto/CreationEntity"));
+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) => new CreationEntity_1.default(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/useFetchCollection/index.d.ts

@@ -0,0 +1,19 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { searchSchema as schema } from '@ludo.ninja/api';
+import CollectionEntity from '@/dto/Collection/CollectionEntity';
+declare const prefetchCollection: ({ collectionId }: {
+    collectionId: string;
+}, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchCollection: null;
+    };
+}>;
+declare const useFetchCollection: ({ collectionId, prefetchedCollection, }: {
+    collectionId: string;
+    prefetchedCollection: schema.ICollection | null;
+}) => {
+    isLoadingCollection: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    collection: CollectionEntity | null;
+};
+export { prefetchCollection, useFetchCollection };

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

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchCollection = exports.prefetchCollection = 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 CollectionEntity_1 = __importDefault(require("@/dto/Collection/CollectionEntity"));
+const prefetchCollection = ({ collectionId }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.searchSchema.FetchCollectionDocument,
+        variables: { collectionId },
+        context: { uri: api_1.hosts.searchHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchCollection: null },
+        };
+    });
+};
+exports.prefetchCollection = prefetchCollection;
+const useFetchCollection = ({ collectionId, prefetchedCollection, }) => {
+    const [collection, setCollection] = (0, react_1.useState)(prefetchedCollection ? new CollectionEntity_1.default(prefetchedCollection) : null);
+    const [isLoadingCollection, setIsLoadingCollection] = (0, react_1.useState)(!prefetchedCollection);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { error } = (0, client_1.useQuery)(api_1.searchSchema.FetchCollectionDocument, {
+        variables: { collectionId },
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: 'cache-first',
+        onCompleted: ({ fetchCollection }) => {
+            if (fetchCollection) {
+                setCollection(new CollectionEntity_1.default(fetchCollection));
+            }
+            setIsLoadingCollection(false);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+            setCollection(null);
+            setIsLoadingCollection(false);
+        },
+    });
+    return {
+        isLoadingCollection,
+        error,
+        collection,
+    };
+};
+exports.useFetchCollection = useFetchCollection;

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

@@ -0,0 +1,23 @@
+import { searchSchema as schema } from '@ludo.ninja/api';
+import CollectionCreationEntity from '@/dto/Collection/CollectionCreationEntity';
+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: CollectionCreationEntity[];
+    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: CollectionCreationEntity[];
+        nextPageToken: string | null;
+        refetchQuery: () => Promise<void>;
+    };
+};
+export default _default;

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

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFindCollections = 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 CollectionCreationEntity_1 = __importDefault(require("@/dto/Collection/CollectionCreationEntity"));
+// 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) => new CollectionCreationEntity_1.default({
+                ...collection,
+                name: collection.collectionTitle,
+            }, '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 { searchSchema as schema } from '@ludo.ninja/api';
+import CollectionCreationEntity from '@/dto/Collection/CollectionCreationEntity';
+declare const useFetchDynamicCollectionData: ({ input, }: schema.IQueryFetchDynamicCollectionDataArgs) => {
+    loadMore: (pageToken: string | null) => Promise<void>;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    refetchQuery: () => Promise<void>;
+    collectionAssetsList: CollectionCreationEntity[];
+    nextPageToken: string | null;
+    likesCount: number;
+    isLikedByUser: boolean;
+};
+export { useFetchDynamicCollectionData };

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

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchDynamicCollectionData = 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 CollectionCreationEntity_1 = __importDefault(require("@/dto/Collection/CollectionCreationEntity"));
+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) => new CollectionCreationEntity_1.default({
+                ...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) => new CollectionCreationEntity_1.default({
+                    ...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 { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { searchSchema as schema } from '@ludo.ninja/api';
+import { ProfileEntity } from '@ludo.ninja/core';
+import AssetEntity from '@/dto/AssetEntity';
+export declare const prefetchFindAllTopEntitiesByName: ({ name, pageSize }: schema.IQueryFindAllTopEntitiesByNameArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        findAllTopEntitiesByName: null;
+    };
+}>;
+export declare const useFetchFindAllTopEntitiesByName: () => {
+    data: schema.IFindAllTopEntitiesByNameQuery | undefined;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    load: ({ name, pageSize }: schema.IQueryFindAllTopEntitiesByNameArgs) => Promise<import("@apollo/client").QueryResult<schema.IFindAllTopEntitiesByNameQuery, schema.Exact<{
+        name: string;
+        pageSize: number;
+    }>>>;
+    topEntities: {
+        assets: AssetEntity[];
+        collections: schema.ICollection[];
+        profiles: ProfileEntity[];
+    } | null;
+    clearTopEntitiesState: () => void;
+};
+declare const _default: {
+    useFetchFindAllTopEntitiesByName: () => {
+        data: schema.IFindAllTopEntitiesByNameQuery | undefined;
+        loading: boolean;
+        error: import("@apollo/client").ApolloError | undefined;
+        load: ({ name, pageSize }: schema.IQueryFindAllTopEntitiesByNameArgs) => Promise<import("@apollo/client").QueryResult<schema.IFindAllTopEntitiesByNameQuery, schema.Exact<{
+            name: string;
+            pageSize: number;
+        }>>>;
+        topEntities: {
+            assets: AssetEntity[];
+            collections: schema.ICollection[];
+            profiles: ProfileEntity[];
+        } | null;
+        clearTopEntitiesState: () => void;
+    };
+    prefetchFindAllTopEntitiesByName: ({ name, pageSize }: schema.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,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchFindAllTopEntitiesByName = exports.prefetchFindAllTopEntitiesByName = void 0;
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const core_1 = require("@ludo.ninja/core");
+const AssetEntity_1 = __importDefault(require("@/dto/AssetEntity"));
+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) => new AssetEntity_1.default(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/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;

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

@@ -0,0 +1,34 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { searchSchema as schema } from '@ludo.ninja/api';
+import CreationEntity from '@/dto/CreationEntity';
+export declare const prefetchFindCreations: ({ term, input, page }: schema.IQueryFindCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        findCreations: null;
+    };
+}>;
+export declare const useFindCreations: ({ term, input, page, }: schema.IQueryFindCreationsArgs) => {
+    loadMore: (pageToken: string | null) => Promise<void>;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    results: number;
+    creations: CreationEntity[];
+    nextPageToken: string | null;
+    refetchQuery: () => Promise<void>;
+};
+declare const _default: {
+    useFindCreations: ({ term, input, page, }: schema.IQueryFindCreationsArgs) => {
+        loadMore: (pageToken: string | null) => Promise<void>;
+        loading: boolean;
+        error: import("@apollo/client").ApolloError | undefined;
+        results: number;
+        creations: CreationEntity[];
+        nextPageToken: string | null;
+        refetchQuery: () => Promise<void>;
+    };
+    prefetchFindCreations: ({ term, input, page }: schema.IQueryFindCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+        data: {
+            findCreations: null;
+        };
+    }>;
+};
+export default _default;