@ludo.ninja/components 2.0.1 → 2.0.2

package/build/api/server-identities/mutations/useSaveEmailOfJoiner/index.d.ts

@@ -0,0 +1,7 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useSaveEmailOfJoiner: () => {
+    saveEmailOfJoiner: ({ email, isSubscribed, }: schema.IMutationSaveEmailOfJoinerArgs) => Promise<import("@apollo/client").FetchResult<schema.ISaveEmailOfJoinerMutation>>;
+    error: import("@apollo/client").ApolloError | undefined;
+    loading: boolean;
+};
+export default useSaveEmailOfJoiner;

package/build/api/server-identities/mutations/useSaveEmailOfJoiner/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("@/store/ui");
+const useSaveEmailOfJoiner = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error, loading }] = api_1.identitySchema.useSaveEmailOfJoinerMutation({
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'Success!',
+                text: 'You subscribed',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { saveEmailOfJoiner, error, loading };
+    async function saveEmailOfJoiner({ email, isSubscribed, }) {
+        return mutate({
+            variables: { email, isSubscribed },
+        });
+    }
+};
+exports.default = useSaveEmailOfJoiner;

package/build/api/server-identities/mutations/useUnfollowProfile/index.d.ts

@@ -0,0 +1,7 @@
+declare const useUnfollowProfile: (followingUserId: string) => {
+    unfollowProfile: (options?: import("@apollo/client").MutationFunctionOptions<any, import("@apollo/client").OperationVariables, {
+        uri: string;
+    }, import("@apollo/client").ApolloCache<any>> | undefined) => Promise<import("@apollo/client").FetchResult<any>>;
+    isUnFollowedProfile: boolean;
+};
+export default useUnfollowProfile;

package/build/api/server-identities/mutations/useUnfollowProfile/index.js

@@ -0,0 +1,39 @@
+"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 UNFOLLOW_PROFILE_MUTATION = (0, client_1.gql) `
+  mutation UnfollowProfile($followingUserId: ID!) {
+    unfollowProfile(followingUserId: $followingUserId)
+  }
+`;
+const useUnfollowProfile = (followingUserId) => {
+    const [isUnFollowedProfile, setIsUnFollowed] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [unfollowProfile, {}] = (0, client_1.useMutation)(UNFOLLOW_PROFILE_MUTATION, {
+        variables: { followingUserId },
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: ({ unfollowProfile }) => {
+            setIsUnFollowed(unfollowProfile);
+            openAlert({
+                type: type_1.alertVariants.success,
+                caption: 'You successfully unsubscribed!',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            setIsUnFollowed(false);
+        },
+    });
+    return { unfollowProfile, isUnFollowedProfile };
+};
+exports.default = useUnfollowProfile;

package/build/api/server-identities/queries/useFetchProfile/index.d.ts

@@ -0,0 +1,16 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { identitySchema as schema } from '@ludo.ninja/api';
+import { ProfileEntity } from '@ludo.ninja/core';
+declare const prefetchProfile: ({ userId }: schema.IQueryFetchProfileArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchProfile: null;
+    };
+}>;
+declare const useFetchProfile: ({ userId }: schema.IQueryFetchProfileArgs, prefetchedProfile: ProfileEntity | null) => {
+    refetch: (variables?: Partial<import("@apollo/client").OperationVariables> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
+    data: any;
+    clientProfileData: ProfileEntity | null;
+    clientProfileLoading: boolean;
+    clientProfileError: import("@apollo/client").ApolloError | undefined;
+};
+export { prefetchProfile, useFetchProfile };

package/build/api/server-identities/queries/useFetchProfile/index.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchProfile = exports.prefetchProfile = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const core_1 = require("@ludo.ninja/core");
+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 prefetchProfile = ({ userId }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.identitySchema.FetchProfileDocument,
+        variables: { userId },
+        context: { uri: api_1.hosts.serverIdentityHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchProfile: null },
+        };
+    });
+};
+exports.prefetchProfile = prefetchProfile;
+const useFetchProfile = ({ userId }, prefetchedProfile) => {
+    const [profile, setProfile] = (0, react_1.useState)(prefetchedProfile);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { profileData, isLoadingProfileData, user } = (0, store_1.useUserStore)((state) => ({
+        profileData: state.profileData,
+        isLoadingProfileData: state.isLoadingProfileData,
+        user: state.user,
+    }));
+    const [fetchProfile, { data, error, refetch }] = (0, client_1.useLazyQuery)(api_1.identitySchema.FetchProfileDocument, {
+        variables: { userId },
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: ({ fetchProfile }) => {
+            setProfile(new core_1.ProfileEntity(fetchProfile));
+            setIsLoading(false);
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            setProfile(null);
+            setIsLoading(false);
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        if (!prefetchedProfile) {
+            if (userId === user?.userId) {
+                if (!isLoadingProfileData && !profileData) {
+                    setProfile(null);
+                    setIsLoading(true);
+                    fetchProfile();
+                }
+                else {
+                    setProfile(profileData);
+                }
+            }
+            else {
+                setProfile(null);
+                setIsLoading(true);
+                fetchProfile();
+            }
+        }
+    }, [isLoadingProfileData, profileData, userId]);
+    return {
+        refetch,
+        data,
+        clientProfileData: profile,
+        clientProfileLoading: isLoading,
+        clientProfileError: error,
+    };
+};
+exports.useFetchProfile = useFetchProfile;

package/build/api/server-identities/queries/useFetchUserWallets/index.d.ts

@@ -0,0 +1,7 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useFetchUserWallets: ({ userId }: schema.IQueryFetchUserWalletsArgs) => {
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    userWallets: schema.IWallet[];
+};
+export default useFetchUserWallets;

package/build/api/server-identities/queries/useFetchUserWallets/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const useFetchUserWallets = ({ userId }) => {
+    const { loading, error, data } = api_1.identitySchema.useFetchUserWalletsQuery({
+        variables: { userId },
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+    });
+    return {
+        loading,
+        error,
+        userWallets: data?.fetchUserWallets
+            ?.slice()
+            .sort((wallet, nextWallet) => Number(nextWallet?.mainWallet) - Number(wallet?.mainWallet)) || null,
+    };
+};
+exports.default = useFetchUserWallets;

package/build/api/server-medias/mutations/useDeleteUserpic/index.d.ts

@@ -0,0 +1,6 @@
+declare const useDeleteUserpic: () => {
+    deleteUserpic: (options?: import("@apollo/client").MutationFunctionOptions<any, import("@apollo/client").OperationVariables, {
+        uri: string;
+    }, import("@apollo/client").ApolloCache<any>> | undefined) => Promise<import("@apollo/client").FetchResult<any>>;
+};
+export default useDeleteUserpic;

package/build/api/server-medias/mutations/useDeleteUserpic/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const DELETE_USERPIC_MUTATION = (0, client_1.gql) `
+  mutation DeleteUserpic {
+    deleteUserpic
+  }
+`;
+const useDeleteUserpic = () => {
+    const [deleteUserpic] = (0, client_1.useMutation)(DELETE_USERPIC_MUTATION, {
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        refetchQueries: [api_1.mediasSchema.FetchUserpicDocument],
+        // onError: (err) => console.log(err),
+    });
+    return { deleteUserpic };
+};
+exports.default = useDeleteUserpic;

package/build/api/server-medias/mutations/useUploadUserpic/index.d.ts

@@ -0,0 +1,4 @@
+declare const useUploadUserpic: () => {
+    uploadUserpic: (file: File) => Promise<import("@apollo/client").FetchResult<any>>;
+};
+export default useUploadUserpic;

package/build/api/server-medias/mutations/useUploadUserpic/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const UPLOAD_USERPIC_MUTATION = (0, client_1.gql) `
+  mutation UploadUserpic($file: Upload!) {
+    uploadUserpic(file: $file)
+  }
+`;
+const useUploadUserpic = () => {
+    const [mutate] = (0, client_1.useMutation)(UPLOAD_USERPIC_MUTATION, {
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        refetchQueries: [api_1.mediasSchema.FetchUserpicDocument],
+        // onError: (err) => {
+        //   throw new Error(err as string)
+        // },
+    });
+    return { uploadUserpic };
+    async function uploadUserpic(file) {
+        return await mutate({
+            variables: { file },
+        });
+    }
+};
+exports.default = useUploadUserpic;

package/build/api/server-medias/queries/useFetchUserPic/index.d.ts

@@ -0,0 +1,12 @@
+import { mediasSchema as schema } from '@ludo.ninja/api';
+declare const useFetchUserpic: () => {
+    data: schema.IFetchUserpicQuery | undefined;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    refetch: (variables?: Partial<schema.Exact<{
+        userId: string;
+    }>> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<schema.IFetchUserpicQuery>>;
+    load: (userId: string) => void;
+    userPic: string | null;
+};
+export default useFetchUserpic;

package/build/api/server-medias/queries/useFetchUserPic/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const env_1 = require("@/store/env");
+const useFetchUserpic = () => {
+    const getMediaENVDomain = (0, env_1.useEnvStore)((state) => state.getMediaDomain);
+    const [userPic, setUserPic] = (0, react_1.useState)(null);
+    const [fetchUserpic, { data, error, loading, refetch }] = api_1.mediasSchema.useFetchUserpicLazyQuery({
+        context: {
+            uri: api_1.hosts.mediasHost,
+        },
+        onCompleted: ({ fetchUserpic }) => {
+            if (fetchUserpic) {
+                setUserPic(`${getMediaENVDomain()}/userpics/${fetchUserpic}`);
+            }
+            else {
+                setUserPic(null);
+            }
+        },
+        onError: () => {
+            setUserPic(null);
+        },
+    });
+    function load(userId) {
+        fetchUserpic({
+            variables: { userId },
+        });
+    }
+    return {
+        data,
+        loading,
+        error,
+        refetch,
+        load,
+        userPic,
+    };
+};
+exports.default = useFetchUserpic;

package/build/api/server-opportunities/mutations/useDislikeOpportunity.d.ts

@@ -0,0 +1,4 @@
+import { opportunitiesSchema } from '@ludo.ninja/api';
+export declare const useDislikeOpportunity: () => {
+    dislikeOpportunityAction: ({ opportunityId, }: opportunitiesSchema.IMutationDislikeOpportunityArgs) => Promise<void>;
+};

package/build/api/server-opportunities/mutations/useDislikeOpportunity.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDislikeOpportunity = void 0;
+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 useDislikeOpportunity = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.opportunitiesSchema.useDislikeOpportunityMutation({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        // onCompleted: () => {
+        // },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    async function dislikeOpportunityAction({ opportunityId, }) {
+        await mutate({
+            variables: { opportunityId },
+        });
+    }
+    return { dislikeOpportunityAction };
+};
+exports.useDislikeOpportunity = useDislikeOpportunity;

package/build/api/server-opportunities/mutations/useLikeOpportunity.d.ts

@@ -0,0 +1,4 @@
+import { opportunitiesSchema } from '@ludo.ninja/api';
+export declare const useLikeOpportunity: () => {
+    likeOpportunityAction: ({ opportunityId, }: opportunitiesSchema.IMutationLikeOpportunityArgs) => Promise<void>;
+};

package/build/api/server-opportunities/mutations/useLikeOpportunity.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLikeOpportunity = void 0;
+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 useLikeOpportunity = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.opportunitiesSchema.useLikeOpportunityMutation({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        // onCompleted: () => {
+        // },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    async function likeOpportunityAction({ opportunityId, }) {
+        await mutate({
+            variables: { opportunityId },
+        });
+    }
+    return { likeOpportunityAction };
+};
+exports.useLikeOpportunity = useLikeOpportunity;

package/build/api/server-opportunities/mutations/useOpenOpportunity/index.d.ts

@@ -0,0 +1,5 @@
+import { opportunitiesSchema as schema } from '@ludo.ninja/api';
+declare const useOpenOpportunity: () => {
+    openOpportunityAction: ({ opportunityId, }: schema.IMutationOpenOpportunityArgs) => Promise<void>;
+};
+export default useOpenOpportunity;

package/build/api/server-opportunities/mutations/useOpenOpportunity/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 useOpenOpportunity = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.opportunitiesSchema.useOpenOpportunityMutation({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        // onCompleted: () => {
+        // },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+        },
+    });
+    async function openOpportunityAction({ opportunityId, }) {
+        await mutate({
+            variables: { opportunityId },
+        });
+    }
+    return { openOpportunityAction };
+};
+exports.default = useOpenOpportunity;

package/build/api/server-opportunities/queries/useGetOpportunities.d.ts

@@ -0,0 +1,4 @@
+export declare const useGetOpportunities: () => {
+    opportunities: import("@ludo.ninja/api/build/graphql_tools/__generated__/opportunitiesHost/schema").Maybe<Pick<import("@ludo.ninja/api/build/graphql_tools/__generated__/opportunitiesHost/schema").IOpportunityV2, "collection" | "liked" | "media" | "name" | "views" | "createdAt" | "blockchain" | "description" | "opportunityId" | "brandId" | "categoryId" | "opportunityStatus" | "opportunityType" | "notificationType" | "brandName" | "brandDescription" | "brandMedia" | "brandUrl" | "brandIndustry" | "categoryName" | "ludoUrl" | "projectUrl" | "activeFrom" | "activeUntil" | "minXpLevel" | "maxXpLevel" | "minRank" | "maxRank" | "reportLink" | "clicks" | "minWalletValue" | "maxWalletValue" | "shareLink">>[] | undefined;
+    isLoadingOpportunities: boolean;
+};

package/build/api/server-opportunities/queries/useGetOpportunities.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetOpportunities = void 0;
+const api_1 = require("@ludo.ninja/api");
+const schema_1 = require("@ludo.ninja/api/build/graphql_tools/__generated__/opportunitiesHost/schema");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const ui_1 = require("@/store/ui");
+const useGetOpportunities = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { data, loading } = (0, schema_1.useFetchOpportunitiesForProfileQuery)({
+        context: {
+            uri: api_1.hosts.opportunitiesHost,
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: 'Oops, something went wrong.',
+            });
+        },
+    });
+    return {
+        opportunities: data?.fetchOpportunitiesForProfile,
+        isLoadingOpportunities: loading,
+    };
+};
+exports.useGetOpportunities = useGetOpportunities;

package/build/api/server-preferences/queries/fetchSearchResultSelections/index.d.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<schema.IFetchSearchResultSelectionsQuery> | {
+    data: {
+        fetchSearchResultSelections: null;
+    };
+}>;
+export declare const useFetchSearchResultSelections: () => {
+    resultTimeSelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultSelections: {
+        typeSelections: schema.Maybe<Pick<schema.ISelection, "label"> & {
+            id: string;
+        }>[];
+        blockchainSelections: schema.Maybe<Pick<schema.ISelection, "label"> & {
+            id: string;
+        }>[];
+        categorySelections: schema.Maybe<Pick<schema.ISelection, "label"> & {
+            id: string;
+        }>[];
+        timeSelections: schema.Maybe<Pick<schema.ISelection, "label"> & {
+            id: string;
+        }>[];
+        statusSelections: schema.Maybe<Pick<schema.ISelection, "label"> & {
+            id: string;
+        }>[];
+    } | undefined;
+};

package/build/api/server-preferences/queries/fetchSearchResultSelections/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchSearchResultSelections = exports.prefetchSearchResultSelections = void 0;
+const api_1 = require("@ludo.ninja/api");
+const context = {
+    uri: api_1.hosts.preferencesHost,
+};
+const prefetchSearchResultSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultSelectionsDocument,
+        context,
+        fetchPolicy: 'no-cache',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultSelections = prefetchSearchResultSelections;
+const useFetchSearchResultSelections = () => {
+    const { error, loading, data } = api_1.preferencesSchema.useFetchSearchResultSelectionsQuery({
+        context,
+        fetchPolicy: 'no-cache',
+    });
+    return {
+        resultTimeSelectionsLoading: loading,
+        error,
+        searchResultSelections: data?.fetchSearchResultSelections,
+    };
+};
+exports.useFetchSearchResultSelections = useFetchSearchResultSelections;

package/build/api/server-preferences/queries/fetchSearchResultSelections/queryData.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import * as querystring from 'querystring';
+import { ICollectionFilterInput, ICreationFilterInput } from '@ludo.ninja/api/build/graphql_tools/__generated__/searchHost/schema';
+export interface DefaultsCollectionsSearchPageProps extends ICollectionFilterInput {
+    term: string;
+}
+export interface DefaultsNftSearchPageProps extends ICreationFilterInput {
+    term: string;
+}
+export declare const getQueryData: (query: querystring.ParsedUrlQuery, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<{
+    nft(): DefaultsNftSearchPageProps;
+    collections(): DefaultsCollectionsSearchPageProps;
+} | null>;

package/build/api/server-preferences/queries/fetchSearchResultSelections/queryData.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueryData = void 0;
+const index_1 = require("@/api/server-preferences/queries/fetchSearchResultSelections/index");
+const helpers_1 = require("@/system/Filters/helpers");
+const getQueryData = async (query, apolloClient) => {
+    const { term, type, time, blockchain, category, status } = query;
+    const { data: { fetchSearchResultSelections }, } = await (0, index_1.prefetchSearchResultSelections)(apolloClient);
+    // const res = await prefetchSearchResultSelections(apolloClient);
+    // console.log(JSON.stringify(res, null, ' '));
+    if (!fetchSearchResultSelections) {
+        // redirect to home page if error fetch selections
+        return null;
+    }
+    const defaults = {
+        term: term ? term : '',
+        time: (0, helpers_1.findDefaultFilterValue)(time, fetchSearchResultSelections.timeSelections, fetchSearchResultSelections.timeSelections[0]?.id),
+        blockchain: (0, helpers_1.findDefaultFilterValue)(blockchain, fetchSearchResultSelections.blockchainSelections, fetchSearchResultSelections.blockchainSelections[0]?.id),
+        category: (0, helpers_1.findDefaultFilterValue)(category, fetchSearchResultSelections.categorySelections, fetchSearchResultSelections.categorySelections[0]?.id),
+        status: (0, helpers_1.findDefaultFilterValue)(status, fetchSearchResultSelections.statusSelections, fetchSearchResultSelections.statusSelections[0]?.id),
+    };
+    return {
+        nft() {
+            return {
+                ...defaults,
+                type: (0, helpers_1.findDefaultFilterValue)(type, fetchSearchResultSelections.typeSelections, fetchSearchResultSelections.typeSelections[0]?.id),
+            };
+        },
+        collections() {
+            return defaults;
+        },
+        // gallery() {
+        //   return;
+        // },
+    };
+};
+exports.getQueryData = getQueryData;

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

@@ -0,0 +1,32 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { searchSchema as schema } from '@ludo.ninja/api';
+import CreationEntity from '@/dto/CreationEntity';
+export declare const prefetchAllCreations: ({ page }: schema.IQueryFetchAllCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchAllCreations: null;
+    };
+}>;
+export declare const useFetchAllCreations: ({ page, }: schema.IQueryFetchAllCreationsArgs) => {
+    loadMore: (pageToken: string | null) => Promise<void>;
+    loading: boolean;
+    refetchQuery: () => Promise<void>;
+    error: import("@apollo/client").ApolloError | undefined;
+    allCreations: CreationEntity[];
+    nextPageToken: string | null;
+};
+declare const _default: {
+    useFetchAllCreations: ({ page, }: schema.IQueryFetchAllCreationsArgs) => {
+        loadMore: (pageToken: string | null) => Promise<void>;
+        loading: boolean;
+        refetchQuery: () => Promise<void>;
+        error: import("@apollo/client").ApolloError | undefined;
+        allCreations: CreationEntity[];
+        nextPageToken: string | null;
+    };
+    prefetchAllCreations: ({ page }: schema.IQueryFetchAllCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+        data: {
+            fetchAllCreations: null;
+        };
+    }>;
+};
+export default _default;