@ludo.ninja/components 2.3.6 → 2.3.7

package/build/modules/opportunity/type.d.ts

@@ -0,0 +1,2 @@
+import { opportunitiesSchema } from '@ludo.ninja/api';
+export type TOpportunity = Pick<opportunitiesSchema.IOpportunityV2, 'opportunityId' | 'brandId' | 'categoryId' | 'opportunityStatus' | 'opportunityType' | 'notificationType' | 'name' | 'description' | 'brandName' | 'brandDescription' | 'brandMedia' | 'brandUrl' | 'brandIndustry' | 'categoryName' | 'ludoUrl' | 'projectUrl' | 'activeFrom' | 'activeUntil' | 'minXpLevel' | 'maxXpLevel' | 'minRank' | 'maxRank' | 'media' | 'reportLink' | 'clicks' | 'views' | 'blockchain' | 'collection' | 'createdAt' | 'minWalletValue' | 'maxWalletValue' | 'shareLink' | 'liked' | 'participantsLimit' | 'availablePlacesForAirdrop'>;

package/build/modules/opportunity/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/modules/sessionScroll/globalTabs.d.ts

@@ -0,0 +1,12 @@
+import { TabsNavType } from '../../system/Tabs/TabsNav/type';
+export declare const globalTabs: {
+    profileNft: TabsNavType;
+    profileFavorites: TabsNavType;
+    profileGalleries: TabsNavType;
+    collection: TabsNavType;
+    favorite: TabsNavType;
+    gallery: TabsNavType;
+    searchCollections: TabsNavType;
+    searchNfts: TabsNavType;
+    searchProfiles: TabsNavType;
+};

package/build/modules/sessionScroll/globalTabs.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalTabs = void 0;
+exports.globalTabs = {
+    profileNft: {
+        value: 'profileNft',
+        label: 'nfts',
+        id: 1,
+    },
+    profileFavorites: {
+        value: 'profileFavorites',
+        id: 5,
+        label: 'favorites',
+    },
+    profileGalleries: {
+        value: 'profileGalleries',
+        id: 6,
+        label: 'galleries',
+    },
+    collection: {
+        value: 'collectionId',
+        label: 'collectionId',
+        id: 2,
+    },
+    favorite: {
+        value: 'favoriteId',
+        label: 'favoriteId',
+        id: 3,
+    },
+    gallery: {
+        value: 'galleryId',
+        label: 'galleryId',
+        id: 4,
+    },
+    searchCollections: {
+        value: 'searchCollections',
+        label: 'collections',
+        id: 7,
+    },
+    searchNfts: {
+        value: 'searchNfts',
+        label: 'nfts',
+        id: 8,
+    },
+    searchProfiles: {
+        value: 'searchProfiles',
+        label: 'profiles',
+        id: 8,
+    },
+};

package/build/modules/sessionScroll/index.d.ts

@@ -0,0 +1,14 @@
+import { TScrollKey } from "./type";
+export declare const getScrollKeys: () => TScrollKey | null;
+export declare const removeScrollKeys: () => void;
+export declare const setScrollKeys: (data: TScrollKey) => void;
+interface ScrollStore {
+    isHandleUpdateScroll: boolean;
+    setIsHandleUpdateScroll: (isHandleUpdateScroll: boolean) => void;
+    backRoute: string;
+    setBackRoute: (backRoute: string) => void;
+    removeScrollKeysWithCheckRoute: (url: string) => void;
+}
+export declare const useScrollState: import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<ScrollStore>>;
+export declare const DeleteScrollStateInterceptor: () => null;
+export {};

package/build/modules/sessionScroll/index.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteScrollStateInterceptor = exports.useScrollState = exports.setScrollKeys = exports.removeScrollKeys = exports.getScrollKeys = void 0;
+const react_1 = require("react");
+const router_1 = require("next/router");
+const traditional_1 = require("zustand/traditional");
+const utils_1 = require("@ludo.ninja/utils");
+const shallow_1 = require("zustand/shallow");
+const sessionKey = "scrollPositions";
+const getScrollKeys = () => {
+    const result = (0, utils_1.getSessionKey)(sessionKey);
+    if (result) {
+        return JSON.parse(result);
+    }
+    return null;
+};
+exports.getScrollKeys = getScrollKeys;
+const removeScrollKeys = () => {
+    sessionStorage.removeItem(sessionKey);
+};
+exports.removeScrollKeys = removeScrollKeys;
+const setScrollKeys = (data) => {
+    if (utils_1.isServer)
+        return;
+    (0, exports.removeScrollKeys)();
+    sessionStorage.setItem(sessionKey, JSON.stringify(data));
+};
+exports.setScrollKeys = setScrollKeys;
+exports.useScrollState = (0, traditional_1.createWithEqualityFn)()((setState, getState) => ({
+    isHandleUpdateScroll: false,
+    setIsHandleUpdateScroll: (isHandleUpdateScroll) => {
+        setState({ isHandleUpdateScroll });
+    },
+    backRoute: "",
+    setBackRoute: (backRoute) => {
+        setState({ backRoute });
+    },
+    removeScrollKeysWithCheckRoute: (url) => {
+        const { isHandleUpdateScroll, backRoute } = getState();
+        if (!isHandleUpdateScroll && url !== backRoute) {
+            (0, exports.removeScrollKeys)();
+        }
+        else {
+            setState({
+                isHandleUpdateScroll: false,
+            });
+        }
+    },
+}), shallow_1.shallow);
+// custom Component Interceptor scroll state without global page rerender in effect
+const DeleteScrollStateInterceptor = () => {
+    const removeScrollKeysWithCheckRoute = (0, exports.useScrollState)((state) => state.removeScrollKeysWithCheckRoute);
+    const router = (0, router_1.useRouter)();
+    (0, react_1.useEffect)(() => {
+        router.events.on("routeChangeStart", removeScrollKeysWithCheckRoute);
+        return () => {
+            router.events.off("routeChangeStart", removeScrollKeysWithCheckRoute);
+        };
+    }, []);
+    return null;
+};
+exports.DeleteScrollStateInterceptor = DeleteScrollStateInterceptor;

package/build/modules/sessionScroll/type.d.ts

@@ -0,0 +1,7 @@
+export type TScrollKey = {
+    [a: string]: {
+        pageOffsetKey: number;
+        itemIndexKey: number;
+        itemsCountKey: number;
+    };
+};

package/build/modules/sessionScroll/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/modules/sessionScroll/useVirtuosoInitialScroll.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+import { VirtuosoHandle } from 'react-virtuoso';
+import { TVirtuosoData } from '../virtuoso/types';
+import { TActiveTab } from '../../system/Tabs/TabsNav/type';
+export declare const useVirtuosoInitialScroll: <TData>({ virtuosoData, activeTab, virtuoso, }: {
+    virtuosoData: TVirtuosoData<TData>;
+    activeTab: TActiveTab;
+    virtuoso: RefObject<VirtuosoHandle | null>;
+}) => {
+    updateScroll: (index: number) => void;
+    setScrollTop: (scrollY: number) => void;
+};

package/build/modules/sessionScroll/useVirtuosoInitialScroll.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVirtuosoInitialScroll = void 0;
+const react_1 = require("react");
+const router_1 = require("next/router");
+const index_1 = require("./index");
+const useVirtuosoInitialScroll = ({ virtuosoData, activeTab, virtuoso, }) => {
+    const scrollTop = (0, react_1.useRef)(0);
+    const isFirstScrolling = (0, react_1.useRef)(true);
+    const { setIsHandleUpdateScroll, setBackRoute } = (0, index_1.useScrollState)((state) => ({
+        setIsHandleUpdateScroll: state.setIsHandleUpdateScroll,
+        setBackRoute: state.setBackRoute,
+    }));
+    const router = (0, router_1.useRouter)();
+    (0, react_1.useEffect)(() => {
+        if (virtuosoData.creations.length) {
+            if (activeTab && activeTab.value && isFirstScrolling.current) {
+                const scrollKeys = (0, index_1.getScrollKeys)();
+                if (scrollKeys) {
+                    const scrollPosition = scrollKeys[activeTab.value]?.pageOffsetKey;
+                    const scrollIndex = scrollKeys[activeTab.value]?.itemIndexKey;
+                    if (scrollPosition && scrollIndex) {
+                        virtuoso.current?.scrollToIndex({
+                            index: Number(scrollIndex),
+                            behavior: 'smooth',
+                            align: 'center',
+                        });
+                        // virtuoso.current?.scrollTo({
+                        //   top: Number(scrollPosition),
+                        //   behavior: 'smooth',
+                        // });
+                    }
+                    delete scrollKeys[activeTab.value];
+                    (0, index_1.setScrollKeys)(scrollKeys);
+                    isFirstScrolling.current = false;
+                }
+            }
+        }
+    }, [virtuosoData]);
+    return {
+        updateScroll: (index) => {
+            if (activeTab && activeTab.value) {
+                setIsHandleUpdateScroll(true);
+                (0, index_1.setScrollKeys)({
+                    [activeTab.value]: {
+                        pageOffsetKey: scrollTop.current,
+                        itemsCountKey: virtuosoData.creations.length,
+                        itemIndexKey: index,
+                    },
+                });
+                setBackRoute(router.asPath);
+            }
+        },
+        setScrollTop: (scrollY) => {
+            scrollTop.current = scrollY;
+        },
+    };
+};
+exports.useVirtuosoInitialScroll = useVirtuosoInitialScroll;

package/build/modules/user/auth/HOCAuthSearchParamsLocalhostInterceptor.d.ts

@@ -0,0 +1,3 @@
+import { AppProps } from "next/app";
+import { ReactNode } from "react";
+export declare const HOCAuthSearchParamsLocalhostInterceptor: (Component: ReactNode, pageProps: AppProps["pageProps"]) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<import("react").AwaitedReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/build/modules/user/auth/HOCAuthSearchParamsLocalhostInterceptor.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOCAuthSearchParamsLocalhostInterceptor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const api_1 = require("@ludo.ninja/api");
+const router_1 = require("next/router");
+const react_1 = require("react");
+const AuthLoginQuery = () => {
+    (0, react_1.useEffect)(() => {
+        const currentUrl = new URL(window.location.href);
+        const userId = currentUrl.searchParams.get("userId");
+        const wallets = currentUrl.searchParams.get("wallets");
+        const newUser = currentUrl.searchParams.get("newUser");
+        const inviteCode = currentUrl.searchParams.get("inviteCode");
+        const role = currentUrl.searchParams.get("role");
+        const authToken = currentUrl.searchParams.get("authToken");
+        const refreshToken = currentUrl.searchParams.get("refreshToken");
+        if (userId && wallets && authToken && refreshToken) {
+            api_1.authCookies.assignCookies(userId, JSON.parse(wallets), authToken, refreshToken, String(newUser), inviteCode?.toString() || "null", String(role), "localhost");
+            const paramsToRemove = ["userId", "wallets", "newUser", "inviteCode", "role", "authToken", "refreshToken"];
+            paramsToRemove.forEach((param) => currentUrl.searchParams.delete(param));
+            window.location.href = currentUrl.toString();
+        }
+    }, []);
+    return null;
+};
+const HOCAuthSearchParamsLocalhostInterceptor = (Component, pageProps) => {
+    const router = (0, router_1.useRouter)();
+    if (!pageProps.userData && router.query?.authToken) {
+        return (0, jsx_runtime_1.jsx)(AuthLoginQuery, {});
+    }
+    return Component;
+};
+exports.HOCAuthSearchParamsLocalhostInterceptor = HOCAuthSearchParamsLocalhostInterceptor;

package/build/modules/user/auth/useAuthVerification.d.ts

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

package/build/modules/user/auth/useAuthVerification.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuthVerification = void 0;
+const react_1 = require("react");
+const router_1 = require("next/router");
+const useVerification_1 = require("./useVerification");
+const useAuthVerification = () => {
+    const router = (0, router_1.useRouter)();
+    const verification = (0, useVerification_1.useVerification)();
+    (0, react_1.useEffect)(() => {
+        const authVerification = () => verification(router.pathname);
+        document.addEventListener("visibilitychange", authVerification);
+        return () => {
+            document.removeEventListener("visibilitychange", authVerification);
+        };
+    }, [router.query]);
+};
+exports.useAuthVerification = useAuthVerification;

package/build/modules/user/auth/useSignIn.d.ts

@@ -0,0 +1,2 @@
+import { IUser } from '../../../entities/user/type';
+export declare const useSignIn: () => (user: IUser) => void;

package/build/modules/user/auth/useSignIn.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSignIn = void 0;
+const api_1 = require("@ludo.ninja/api");
+const store_1 = require("../store");
+const env_1 = require("../../../store/env");
+const useSignIn = () => {
+    const setUser = (0, store_1.useUserStore)((state) => state.setUser);
+    const NEXT_PUBLIC_ENV_DOMAIN = (0, env_1.useEnvStore)((state) => state.NEXT_PUBLIC_ENV_DOMAIN);
+    return (user) => {
+        setUser({
+            userId: user.userId,
+            wallets: user.wallets,
+            authToken: user.authToken,
+            refreshToken: user.refreshToken,
+            newUser: user.newUser,
+            inviteCode: user.inviteCode,
+            role: user.role,
+        });
+        api_1.authCookies.assignCookies(user.userId, user.wallets, user.authToken, user.refreshToken, user.newUser.toString(), user.inviteCode, user.role, NEXT_PUBLIC_ENV_DOMAIN);
+    };
+};
+exports.useSignIn = useSignIn;

package/build/modules/user/auth/useSignOut.d.ts

@@ -0,0 +1 @@
+export declare const useSignOut: () => (includeRedirect?: boolean) => Promise<void>;

package/build/modules/user/auth/useSignOut.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSignOut = void 0;
+const store_1 = require("../store");
+const useRevokeToken_1 = __importDefault(require("../../../api/server-identities/mutations/useRevokeToken"));
+const env_1 = require("../../../store/env");
+const api_1 = require("@ludo.ninja/api");
+const ludoDomains_1 = require("@ludo.ninja/core/build/ludoDomains");
+const nookies_1 = require("nookies");
+const useSignOut = () => {
+    const { NEXT_PUBLIC_ENV_VALUE, NEXT_PUBLIC_ENV_DOMAIN } = (0, env_1.useEnvStore)((state) => ({
+        NEXT_PUBLIC_ENV_VALUE: state.NEXT_PUBLIC_ENV_VALUE,
+        NEXT_PUBLIC_ENV_DOMAIN: state.NEXT_PUBLIC_ENV_DOMAIN,
+    }));
+    const { revokeToken } = (0, useRevokeToken_1.default)();
+    const setUser = (0, store_1.useUserStore)((state) => state.setUser);
+    return async (includeRedirect = true) => {
+        try {
+            await revokeToken();
+        }
+        catch (e) {
+            //====
+        }
+        finally {
+            api_1.authCookies.destroyCookies(NEXT_PUBLIC_ENV_DOMAIN);
+            (0, nookies_1.destroyCookie)(null, "authMultiversXWallet", {
+                path: "/",
+                domain: NEXT_PUBLIC_ENV_DOMAIN,
+            });
+            setUser(null);
+            // when invite code is not required = no redirect
+            // window.location.replace(ludoDomains[NEXT_PUBLIC_ENV_VALUE as TEnvValue]["welcome"]);
+            if (includeRedirect && window.location.origin === ludoDomains_1.ludoDomains[NEXT_PUBLIC_ENV_VALUE]["account"]) {
+                window.location.replace(ludoDomains_1.ludoDomains[NEXT_PUBLIC_ENV_VALUE]["welcome"]);
+            }
+        }
+    };
+};
+exports.useSignOut = useSignOut;

package/build/modules/user/auth/useVerification.d.ts

@@ -0,0 +1 @@
+export declare const useVerification: () => (currentLocation: string) => Promise<void>;

package/build/modules/user/auth/useVerification.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVerification = void 0;
+const useSignIn_1 = require("./useSignIn");
+const useSignOut_1 = require("./useSignOut");
+const useVerification = () => {
+    const signIn = (0, useSignIn_1.useSignIn)();
+    const signOut = (0, useSignOut_1.useSignOut)();
+    // const isProd = useEnvStore((state) => state.isProd);
+    return async (currentLocation) => {
+        try {
+            const authCookies = await Promise.resolve().then(() => __importStar(require("@ludo.ninja/api/build/cookies"))); //update check version cookie in client
+            const authCookiesParsed = authCookies.getCookies();
+            if (authCookiesParsed.authToken &&
+                authCookiesParsed.wallets &&
+                authCookiesParsed.refreshToken &&
+                authCookiesParsed.newUser &&
+                authCookiesParsed.userId &&
+                // authCookiesParsed.inviteCode &&
+                authCookiesParsed.role) {
+                signIn({
+                    userId: authCookiesParsed.userId,
+                    wallets: authCookiesParsed.wallets,
+                    authToken: authCookiesParsed.authToken,
+                    refreshToken: authCookiesParsed.refreshToken,
+                    newUser: authCookiesParsed.newUser === "true",
+                    inviteCode: authCookiesParsed.inviteCode || null,
+                    role: authCookiesParsed.role,
+                });
+            }
+            else {
+                // when invite code is not required = no redirect in sign out
+                // if (isProd() && currentLocation !== "/forms/[formId]" && currentLocation !== "/minting") {
+                if (currentLocation !== "/forms/[formId]" && currentLocation !== "/minting") {
+                    await signOut(false);
+                }
+            }
+        }
+        catch (e) {
+            // console.error('verification', e);
+        }
+    };
+};
+exports.useVerification = useVerification;

package/build/modules/user/profileData/profileDataInitialization.d.ts

@@ -0,0 +1 @@
+export declare const ProfileDataInitialization: () => import("react/jsx-runtime").JSX.Element | null;

package/build/modules/user/profileData/profileDataInitialization.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileDataInitialization = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const store_1 = require("../store");
+const ui_1 = require("../../../store/ui");
+const api_1 = require("@ludo.ninja/api");
+const api_2 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const useFetchMyActivityStreak_1 = __importDefault(require("../../../api/server-experiences/queries/useFetchMyActivityStreak"));
+const FetcherMyProfile = ( /*{ userId }: { userId: string }*/) => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { setIsLoadingProfileData, setProfileData, 
+    // profileData,
+    setUserExp, setInviteCodes, setMyShareLink, } = (0, store_1.useUserStore)((state) => ({
+        setIsLoadingProfileData: state.setIsLoadingProfileData,
+        setProfileData: state.setProfileData,
+        profileData: state.profileData,
+        setUserExp: state.setUserExp,
+        setInviteCodes: state.setInviteCodes,
+        setMyShareLink: state.setMyShareLink,
+    }));
+    // console.log('profileData', profileData);
+    api_2.identitySchema.useFetchMyProfileV2Query({
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ fetchMyProfileV2: fetchMyProfile }) => {
+            // console.log('fetchMyProfile', fetchMyProfile);
+            setProfileData(fetchMyProfile);
+            if (fetchMyProfile.shareLink) {
+                setMyShareLink(fetchMyProfile.shareLink);
+            }
+            if (fetchMyProfile.xps) {
+                setUserExp({
+                    levelMaxXps: fetchMyProfile.levelMaxXps,
+                    levelMinXps: fetchMyProfile.levelMinXps,
+                    xps: fetchMyProfile.xps,
+                    level: fetchMyProfile.level,
+                });
+            }
+            if (fetchMyProfile.inviteCodes) {
+                setInviteCodes(fetchMyProfile.inviteCodes);
+            }
+            setIsLoadingProfileData(false);
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            setProfileData(null);
+            setIsLoadingProfileData(false);
+        },
+    });
+    (0, useFetchMyActivityStreak_1.default)();
+    return null;
+};
+const ProfileDataInitialization = () => {
+    const userId = (0, store_1.useUserStore)((state) => state.user?.userId);
+    if (!userId)
+        return null;
+    return (0, jsx_runtime_1.jsx)(FetcherMyProfile, {});
+};
+exports.ProfileDataInitialization = ProfileDataInitialization;

package/build/modules/user/store.d.ts

@@ -0,0 +1,42 @@
+import { IUser } from '../../entities/user/type';
+import { ApolloError } from "@apollo/client";
+import { experiencesSchema as schema } from "@ludo.ninja/api";
+import { identitySchema } from "@ludo.ninja/api";
+import { ProfileEntity } from "@ludo.ninja/core";
+export declare const initialUserStreak: Omit<schema.IActivityStreak, 'userId'>;
+type TMyProfile = identitySchema.IFetchMyProfileV2Query["fetchMyProfileV2"];
+export interface IUserStore {
+    user: IUser | null;
+    setUser: (user: IUser | null) => void;
+    isSignedIn: boolean;
+    userExp: schema.IUserXp;
+    setUserExp: (userExp: schema.IUserXp) => void;
+    resetUserExp: () => void;
+    isLoadingExp: boolean;
+    setIsLoadingExp: (isLoadingExp: boolean) => void;
+    errorExp: ApolloError | undefined;
+    setErrorExp: (isErrorExp: ApolloError | undefined) => void;
+    isLoadingProfileData: boolean;
+    setIsLoadingProfileData: (isLoadingProfileData: boolean) => void;
+    profileData: ProfileEntity | null;
+    setProfileData: (profileObject: TMyProfile | null) => void;
+    profileObject: TMyProfile | null;
+    updateProfileData: (profile: Pick<TMyProfile, "showNsfw" | "social" | "about" | "username" | "userpic">) => void;
+    inviteCodes: identitySchema.IInviteCode[];
+    setInviteCodes: (inviteCodes: identitySchema.IInviteCode[]) => void;
+    myShareLink: string;
+    setMyShareLink: (myShareLink: string) => void;
+    userStreak: Omit<schema.IActivityStreak, 'userId'>;
+    setUserStreak: (userStreak: Omit<schema.IActivityStreak, 'userId'>) => void;
+    resetUserStreak: () => void;
+    isLoadingStreak: boolean;
+    setIsLoadingStreak: (isLoadingStreak: boolean) => void;
+    errorStreak: ApolloError | undefined;
+    setErrorStreak: (isErrorStreak: ApolloError | undefined) => void;
+}
+export declare const UserProvider: ({ children, initialState }: {
+    children: import("react").ReactNode;
+    initialState: Partial<IUserStore> | ((prevStore: IUserStore) => Partial<IUserStore>);
+}) => JSX.Element;
+export declare const useUserStore: <F>(selector: (state: IUserStore) => F, equalityFn?: ((a: F, b: F) => boolean) | undefined) => F;
+export {};

package/build/modules/user/store.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserStore = exports.UserProvider = exports.initialUserStreak = void 0;
+const core_1 = require("@ludo.ninja/core");
+const next_zustand_1 = require("next-zustand");
+const shallow_1 = require("zustand/shallow");
+const initialUserExp = {
+    xps: 0,
+    level: 1,
+    levelMaxXps: 0,
+    levelMinXps: 0,
+};
+exports.initialUserStreak = {
+    totalDays: 0,
+    nextStreak: 5,
+    nextBonus: 100,
+};
+const creators = (0, next_zustand_1.createProvider)()((setState) => ({
+    user: null,
+    isSignedIn: false,
+    setUser: (user) => {
+        setState({ user, isSignedIn: !!user });
+    },
+    userExp: initialUserExp,
+    setUserExp: (userExp) => {
+        setState({ userExp });
+    },
+    resetUserExp: () => {
+        setState({ userExp: initialUserExp });
+    },
+    isLoadingExp: false,
+    setIsLoadingExp: (isLoadingExp) => {
+        setState({ isLoadingExp });
+    },
+    errorExp: undefined,
+    setErrorExp: (errorExp) => {
+        setState({ errorExp });
+    },
+    profileObject: null,
+    updateProfileData: (profile) => {
+        setState((prev) => {
+            const newProfileObject = {
+                ...prev.profileObject,
+                ...profile,
+                social: {
+                    ...prev.profileObject?.social,
+                    ...profile.social,
+                },
+            };
+            return {
+                profileObject: newProfileObject,
+                profileData: new core_1.ProfileEntity(newProfileObject),
+            };
+        });
+    },
+    profileData: null,
+    setProfileData: (profileObject) => {
+        if (profileObject) {
+            setState({
+                profileData: new core_1.ProfileEntity(profileObject),
+                profileObject,
+            });
+        }
+        else {
+            setState({ profileData: null, profileObject: null });
+        }
+    },
+    isLoadingProfileData: true,
+    setIsLoadingProfileData: (isLoadingProfileData) => {
+        setState({ isLoadingProfileData });
+    },
+    inviteCodes: [],
+    setInviteCodes: (inviteCodes) => {
+        setState({ inviteCodes });
+    },
+    myShareLink: "",
+    setMyShareLink: (myShareLink) => {
+        setState({ myShareLink });
+    },
+    userStreak: exports.initialUserStreak,
+    setUserStreak: (userStreak) => {
+        setState({ userStreak });
+    },
+    resetUserStreak: () => {
+        setState({ userStreak: exports.initialUserStreak });
+    },
+    isLoadingStreak: false,
+    setIsLoadingStreak: (isLoadingStreak) => {
+        setState({ isLoadingStreak });
+    },
+    errorStreak: undefined,
+    setErrorStreak: (errorStreak) => {
+        setState({ errorStreak });
+    },
+}), shallow_1.shallow);
+exports.UserProvider = creators.Provider;
+exports.useUserStore = creators.getUseStore();