@ludo.ninja/components 2.0.1 → 2.0.3

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,61 @@
+"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 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,
+            });
+        }
+    },
+}));
+// 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 '@/modules/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/useAuthVerification.d.ts

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

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

@@ -0,0 +1,74 @@
+"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.useAuthVerification = void 0;
+const react_1 = require("react");
+const router_1 = require("next/router");
+const useSignIn_1 = require("@/modules/user/auth/useSignIn");
+const useSignOut_1 = require("@/modules/user/auth/useSignOut");
+const useAuthVerification = () => {
+    const router = (0, router_1.useRouter)();
+    const signIn = (0, useSignIn_1.useSignIn)();
+    const signOut = (0, useSignOut_1.useSignOut)();
+    (0, react_1.useEffect)(() => {
+        const verification = async () => {
+            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,
+                        role: authCookiesParsed.role,
+                    });
+                }
+                else {
+                    if (router.pathname !== '/forms/[formId]') {
+                        await signOut();
+                    }
+                }
+            }
+            catch (e) {
+                // console.error('verification', e);
+            }
+        };
+        verification();
+        document.addEventListener('visibilitychange', verification);
+        return () => {
+            document.removeEventListener('visibilitychange', verification);
+        };
+    }, [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("@/modules/user/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: () => () => Promise<void>;

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

@@ -0,0 +1,37 @@
+"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 nookies_1 = require("nookies");
+const api_1 = require("@ludo.ninja/api");
+const env_1 = require("@/store/env");
+const useRevokeToken_1 = __importDefault(require("@/api/server-identities/mutations/useRevokeToken"));
+const store_1 = require("../store");
+const useSignOut = () => {
+    const { NEXT_PUBLIC_WELCOME_HOST, NEXT_PUBLIC_ENV_DOMAIN } = (0, env_1.useEnvStore)((state) => ({
+        NEXT_PUBLIC_WELCOME_HOST: state.NEXT_PUBLIC_WELCOME_HOST,
+        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 () => {
+        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);
+            window.location.replace(NEXT_PUBLIC_WELCOME_HOST);
+        }
+    };
+};
+exports.useSignOut = useSignOut;

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,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileDataInitialization = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+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 store_1 = require("@/modules/user/store");
+const ui_1 = require("@/store/ui");
+const FetcherMyProfile = ( /*{ userId }: { userId: string }*/) => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { setIsLoadingProfileData, setProfileData, 
+    // profileData,
+    setUserExp, setInviteCodes, } = (0, store_1.useUserStore)((state) => ({
+        setIsLoadingProfileData: state.setIsLoadingProfileData,
+        setProfileData: state.setProfileData,
+        profileData: state.profileData,
+        setUserExp: state.setUserExp,
+        setInviteCodes: state.setInviteCodes,
+    }));
+    // console.log('profileData', profileData);
+    api_2.identitySchema.useFetchMyProfileV2Query({
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: ({ fetchMyProfileV2: fetchMyProfile }) => {
+            // console.log('fetchMyProfile', fetchMyProfile);
+            setProfileData(fetchMyProfile);
+            setIsLoadingProfileData(false);
+            if (fetchMyProfile.xps) {
+                setUserExp({
+                    levelMaxXps: fetchMyProfile.levelMaxXps,
+                    levelMinXps: fetchMyProfile.levelMinXps,
+                    xps: fetchMyProfile.xps,
+                    level: fetchMyProfile.level,
+                });
+            }
+            if (fetchMyProfile.inviteCodes) {
+                setInviteCodes(fetchMyProfile.inviteCodes);
+            }
+        },
+        onError: (err) => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: err.message,
+            });
+            setProfileData(null);
+            setIsLoadingProfileData(false);
+        },
+    });
+    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,33 @@
+/// <reference types="react" />
+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';
+import { IUser } from '@/entities/user/type';
+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;
+}
+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,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserStore = exports.UserProvider = void 0;
+const next_zustand_1 = require("next-zustand");
+const shallow_1 = require("zustand/shallow");
+const core_1 = require("@ludo.ninja/core");
+const initialUserExp = {
+    xps: 0,
+    level: 1,
+    levelMaxXps: 0,
+    levelMinXps: 0,
+};
+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 });
+    },
+}), shallow_1.shallow);
+exports.UserProvider = creators.Provider;
+exports.useUserStore = creators.getUseStore();

package/build/modules/virtuoso/VirtuosoPageBuilder.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { ApolloError } from '@apollo/client';
+import { TActiveTab } from '@/system/Tabs/TabsNav/type';
+import { TDimensions } from '@/utils/screen';
+export declare const VirtuosoPageBuilder: <TCreation>({ activeTab, isMobile, creations, windowDimensions, isLoading, error, refetchQuery, loadMore, renderCreation, notFoundText, isNextLoading, headerSlot, isProfileCards, }: {
+    activeTab: TActiveTab;
+    isMobile: boolean;
+    creations: TCreation[];
+    windowDimensions: TDimensions | null;
+    isLoading: boolean;
+    isNextLoading: boolean;
+    error: ApolloError | undefined;
+    refetchQuery: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    renderCreation: (creation: TCreation) => ReactNode;
+    notFoundText?: string | undefined;
+    headerSlot: JSX.Element;
+    isProfileCards?: boolean | undefined;
+}) => import("react/jsx-runtime").JSX.Element;