@ludo.ninja/components 1.5.8 → 1.6.0

package/src/modules/sessionScroll/globalTabs.ts

@@ -1,59 +0,0 @@
-import { TabsNavType } from '@/system/Tabs/TabsNav/type';
-
-export const globalTabs: {
-  profileNft: TabsNavType;
-  profileFavorites: TabsNavType;
-  profileGalleries: TabsNavType;
-  collection: TabsNavType;
-  favorite: TabsNavType;
-  gallery: TabsNavType;
-  searchCollections: TabsNavType;
-  searchNfts: TabsNavType;
-  searchProfiles: TabsNavType;
-} = {
-  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/src/modules/sessionScroll/index.ts

@@ -1,84 +0,0 @@
-import { useEffect } from 'react';
-
-import { useRouter } from 'next/router';
-
-import { createWithEqualityFn } from 'zustand/traditional';
-
-import { getSessionKey, isServer } from '@ludo.ninja/utils';
-
-import { TScrollKey } from './type';
-
-export * from './globalTabs';
-export * from './useVirtuosoInitialScroll';
-
-const sessionKey = 'scrollPositions';
-
-export const getScrollKeys = () => {
-  const result = getSessionKey(sessionKey);
-  if (result) {
-    return JSON.parse(result) as TScrollKey;
-  }
-  return null;
-};
-
-export const removeScrollKeys = () => {
-  sessionStorage.removeItem(sessionKey);
-};
-
-export const setScrollKeys = (data: TScrollKey) => {
-  if (isServer) return;
-  removeScrollKeys();
-  sessionStorage.setItem(sessionKey, JSON.stringify(data));
-};
-
-interface ScrollStore {
-  isHandleUpdateScroll: boolean;
-  setIsHandleUpdateScroll: (isHandleUpdateScroll: boolean) => void;
-
-  backRoute: string;
-  setBackRoute: (backRoute: string) => void;
-
-  removeScrollKeysWithCheckRoute: (url: string) => void;
-}
-
-export const useScrollState = createWithEqualityFn<ScrollStore>()(
-  (setState, getState) => ({
-    isHandleUpdateScroll: false,
-    setIsHandleUpdateScroll: (isHandleUpdateScroll) => {
-      setState({ isHandleUpdateScroll });
-    },
-    backRoute: '',
-    setBackRoute: (backRoute) => {
-      setState({ backRoute });
-    },
-    removeScrollKeysWithCheckRoute: (url) => {
-      const { isHandleUpdateScroll, backRoute } = getState();
-      if (!isHandleUpdateScroll && url !== backRoute) {
-        removeScrollKeys();
-      } else {
-        setState({
-          isHandleUpdateScroll: false,
-        });
-      }
-    },
-  })
-);
-
-// custom Component Interceptor scroll state without global page rerender in effect
-export const DeleteScrollStateInterceptor = () => {
-  const removeScrollKeysWithCheckRoute = useScrollState(
-    (state) => state.removeScrollKeysWithCheckRoute
-  );
-
-  const router = useRouter();
-
-  useEffect(() => {
-    router.events.on('routeChangeStart', removeScrollKeysWithCheckRoute);
-
-    return () => {
-      router.events.off('routeChangeStart', removeScrollKeysWithCheckRoute);
-    };
-  }, []);
-
-  return null;
-};

package/src/modules/sessionScroll/type.ts

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

package/src/modules/sessionScroll/useVirtuosoInitialScroll.ts

@@ -1,77 +0,0 @@
-import { RefObject, useEffect, useRef } from 'react';
-
-import { useRouter } from 'next/router';
-
-import { VirtuosoHandle } from 'react-virtuoso';
-
-import {
-  getScrollKeys,
-  setScrollKeys,
-  useScrollState,
-} from '@/modules/sessionScroll/index';
-import { TScrollKey } from '@/modules/sessionScroll/type';
-import { TVirtuosoData } from '@/modules/virtuoso/types';
-
-import { TActiveTab } from '@/system/Tabs/TabsNav/type';
-
-export const useVirtuosoInitialScroll = <TData>({
-  virtuosoData,
-  activeTab,
-  virtuoso,
-}: {
-  virtuosoData: TVirtuosoData<TData>;
-  activeTab: TActiveTab;
-  virtuoso: RefObject<VirtuosoHandle | null>;
-}) => {
-  const scrollTop = useRef(0);
-  const isFirstScrolling = useRef(true);
-  const { setIsHandleUpdateScroll, setBackRoute } = useScrollState((state) => ({
-    setIsHandleUpdateScroll: state.setIsHandleUpdateScroll,
-    setBackRoute: state.setBackRoute,
-  }));
-  const router = useRouter();
-
-  useEffect(() => {
-    if (virtuosoData.creations.length) {
-      if (activeTab && activeTab.value && isFirstScrolling.current) {
-        const scrollKeys = 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];
-          setScrollKeys(scrollKeys);
-          isFirstScrolling.current = false;
-        }
-      }
-    }
-  }, [virtuosoData]);
-  return {
-    updateScroll: (index: number) => {
-      if (activeTab && activeTab.value) {
-        setIsHandleUpdateScroll(true);
-        setScrollKeys({
-          [activeTab.value]: {
-            pageOffsetKey: scrollTop.current,
-            itemsCountKey: virtuosoData.creations.length,
-            itemIndexKey: index,
-          },
-        } as TScrollKey);
-        setBackRoute(router.asPath);
-      }
-    },
-    setScrollTop: (scrollY: number) => {
-      scrollTop.current = scrollY;
-    },
-  };
-};

package/src/modules/user/auth/useAuthVerification.ts

@@ -1,53 +0,0 @@
-import { useEffect } from 'react';
-
-import { useRouter } from 'next/router';
-
-import { identitySchema as schema } from '@ludo.ninja/api';
-
-import { useSignIn } from '@/modules/user/auth/useSignIn';
-import { useSignOut } from '@/modules/user/auth/useSignOut';
-
-export const useAuthVerification = () => {
-  const router = useRouter();
-  const signIn = useSignIn();
-  const signOut = useSignOut();
-
-  useEffect(() => {
-    const verification = async () => {
-      try {
-        const authCookies = await import('@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 as string[],
-            authToken: authCookiesParsed.authToken,
-            refreshToken: authCookiesParsed.refreshToken,
-            newUser: authCookiesParsed.newUser === 'true',
-            inviteCode: authCookiesParsed.inviteCode,
-            role: authCookiesParsed.role as schema.IRole,
-          });
-        } 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]);
-};

package/src/modules/user/auth/useSignIn.ts

@@ -1,31 +0,0 @@
-import { authCookies } from '@ludo.ninja/api';
-
-import { useUserStore } from '@/modules/user/store';
-
-import { IUser } from '@/entities/user/type';
-
-export const useSignIn = () => {
-  const setUser = useUserStore((state) => state.setUser);
-
-  return (user: IUser) => {
-    setUser({
-      userId: user.userId,
-      wallets: user.wallets,
-      authToken: user.authToken,
-      refreshToken: user.refreshToken,
-      newUser: user.newUser,
-      inviteCode: user.inviteCode,
-      role: user.role,
-    });
-    authCookies.assignCookies(
-      user.userId as string,
-      user.wallets as string[],
-      user.authToken as string,
-      user.refreshToken as string,
-      (user.newUser as boolean).toString(),
-      user.inviteCode as string,
-      user.role as string,
-      process.env.NEXT_PUBLIC_ENV_DOMAIN
-    );
-  };
-};

package/src/modules/user/auth/useSignOut.ts

@@ -1,28 +0,0 @@
-import { destroyCookie } from 'nookies';
-import process from 'process';
-
-import { authCookies } from '@ludo.ninja/api';
-
-import useRevokeToken from '@/api/server-identities/mutations/useRevokeToken';
-
-import { useUserStore } from '../store';
-
-export const useSignOut = () => {
-  const { revokeToken } = useRevokeToken();
-  const setUser = useUserStore((state) => state.setUser);
-  return async () => {
-    try {
-      await revokeToken();
-    } catch (e) {
-      //====
-    } finally {
-      authCookies.destroyCookies(process.env.NEXT_PUBLIC_ENV_DOMAIN);
-      destroyCookie(null, 'authMultiversXWallet', {
-        path: '/',
-        domain: process.env.NEXT_PUBLIC_ENV_DOMAIN,
-      });
-      setUser(null);
-      window.location.replace(process.env.NEXT_PUBLIC_WELCOME_HOST);
-    }
-  };
-};

package/src/modules/user/profileData/profileDataInitialization.tsx

@@ -1,67 +0,0 @@
-import { hosts } from '@ludo.ninja/api';
-import { experiencesSchema, identitySchema } from '@ludo.ninja/api';
-import { alertVariants } from '@ludo.ninja/ui/build/system/Alert/type';
-
-import { useUserStore } from '@/modules/user/store';
-
-import { useUiStore } from '@/store/ui';
-
-const FetcherMyProfile = (/*{ userId }: { userId: string }*/) => {
-  const openAlert = useUiStore((state) => state.openAlert);
-  const {
-    setIsLoadingProfileData,
-    setProfileData,
-    // profileData,
-    setUserExp,
-    setInviteCodes,
-  } = useUserStore((state) => ({
-    setIsLoadingProfileData: state.setIsLoadingProfileData,
-    setProfileData: state.setProfileData,
-    profileData: state.profileData,
-    setUserExp: state.setUserExp,
-    setInviteCodes: state.setInviteCodes,
-  }));
-  // console.log('profileData', profileData);
-  identitySchema.useFetchMyProfileQuery({
-    context: {
-      uri: hosts.identityHost,
-    },
-    onCompleted: ({ 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,
-        } as experiencesSchema.IUserXp);
-      }
-      if (fetchMyProfile.inviteCodes) {
-        setInviteCodes(
-          fetchMyProfile.inviteCodes as identitySchema.IUserInviteCode[]
-        );
-      }
-    },
-    onError: (err) => {
-      openAlert({
-        type: alertVariants.error,
-
-        caption: err.message,
-      });
-      setProfileData(null);
-      setIsLoadingProfileData(false);
-    },
-  });
-  return null;
-};
-
-export const ProfileDataInitialization = () => {
-  const userId = useUserStore((state) => state.user?.userId);
-
-  if (!userId) return null;
-
-  return <FetcherMyProfile />;
-};

package/src/modules/user/store.tsx

@@ -1,124 +0,0 @@
-import { ApolloError } from '@apollo/client';
-import { createProvider } from 'next-zustand';
-import { shallow } from 'zustand/shallow';
-
-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';
-
-const initialUserExp = {
-  xps: 0,
-  level: 1,
-  levelMaxXps: 0,
-  levelMinXps: 0,
-} as schema.IUserXp;
-
-type TMyProfile = identitySchema.IFetchMyProfileQuery['fetchMyProfile'];
-
-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.IUserInviteCode[];
-  setInviteCodes: (inviteCodes: identitySchema.IUserInviteCode[]) => void;
-}
-
-const creators = createProvider<IUserStore>()(
-  (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 ProfileEntity(
-            newProfileObject as identitySchema.IProfile
-          ),
-        } as Partial<IUserStore>;
-      });
-    },
-    profileData: null,
-    setProfileData: (profileObject) => {
-      if (profileObject) {
-        setState({
-          profileData: new ProfileEntity(
-            profileObject as identitySchema.IProfile
-          ),
-          profileObject,
-        });
-      } else {
-        setState({ profileData: null, profileObject: null });
-      }
-    },
-    isLoadingProfileData: true,
-    setIsLoadingProfileData: (isLoadingProfileData) => {
-      setState({ isLoadingProfileData });
-    },
-    inviteCodes: [],
-    setInviteCodes: (inviteCodes) => {
-      setState({ inviteCodes });
-    },
-  }),
-  shallow
-);
-
-export const UserProvider = creators.Provider;
-export const useUserStore = creators.getUseStore();