@arthur2079/internal-profile 4.1.2-next.5 → 5.1.2

package/dist/store/selectors.d.ts

@@ -0,0 +1,47 @@
+import type { RootStateLike } from './slice';
+export declare const showPrivateProfileSelector: ((state: RootStateLike, username?: string | undefined) => boolean) & import("reselect").OutputSelectorFields<(args_0: import("./types").ProfileState, args_1: string | undefined) => boolean, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const profileSummarySelector: ((state: RootStateLike, username?: string | undefined) => {
+    loading: boolean;
+    error: string | null;
+    data: import("../api/types").ProfileSummary | null;
+}) & import("reselect").OutputSelectorFields<(args_0: boolean, args_1: import("./types").ProfileState) => {
+    loading: boolean;
+    error: string | null;
+    data: import("../api/types").ProfileSummary | null;
+}, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const privateProfileSummarySelector: ((state: RootStateLike) => {
+    loading: boolean;
+    error: string | null;
+    data: import("../api/types").ProfileSummary | null;
+}) & import("reselect").OutputSelectorFields<(args_0: import("./types").ProfileState) => {
+    loading: boolean;
+    error: string | null;
+    data: import("../api/types").ProfileSummary | null;
+}, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const isLoggedInProfileSelector: ((state: RootStateLike) => boolean) & import("reselect").OutputSelectorFields<(args_0: import("./types").ProfileState) => boolean, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const authenticatedProfileSelector: ((state: RootStateLike) => import("../api/types").ProfileAccount | null) & import("reselect").OutputSelectorFields<(args_0: import("./types").ProfileState) => import("../api/types").ProfileAccount | null, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const usernameProfileSelector: ((state: RootStateLike) => string | null) & import("reselect").OutputSelectorFields<(args_0: import("./types").ProfileState) => string | null, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};

package/dist/store/selectors.js

@@ -0,0 +1,21 @@
+import { createSelector } from '@reduxjs/toolkit';
+const profileSelector = (state) => state.profile;
+const usernameSelector = (_, username) => username;
+export const showPrivateProfileSelector = createSelector([profileSelector, usernameSelector], (profile, username) => {
+    return profile.isLoggedIn && profile.username === username;
+});
+export const profileSummarySelector = createSelector([showPrivateProfileSelector, profileSelector], (showPrivateProfile, profile) => {
+    return showPrivateProfile ? profile.profileSummary.private : profile.profileSummary.public;
+});
+export const privateProfileSummarySelector = createSelector([profileSelector], (profile) => {
+    return profile.profileSummary.private;
+});
+export const isLoggedInProfileSelector = createSelector([profileSelector], (profile) => {
+    return profile.isLoggedIn;
+});
+export const authenticatedProfileSelector = createSelector([profileSelector], (profile) => {
+    return profile.profileAuth.account;
+});
+export const usernameProfileSelector = createSelector([profileSelector], (profile) => {
+    return profile.username;
+});

package/dist/store/slice.d.ts

@@ -0,0 +1,134 @@
+import type { ProfileState } from './types';
+import type { Slice } from '@reduxjs/toolkit';
+import type { BlockchainMeta, SwapperMeta, Token as TokenMeta } from 'rango-types/mainApi';
+export declare const profileSliceInitialState: ProfileState;
+type ActionsFromSlice<T extends Slice> = ReturnType<T['actions'][keyof T['actions']]>;
+export type ProfileSliceActions = ActionsFromSlice<ReturnType<typeof createProfileState>['slice']>;
+export type MetaStateLike = {
+    loadingStatus: 'loading' | 'success' | 'failed';
+    tokens: TokenMeta[];
+    blockchains: BlockchainMeta[];
+    swappers: SwapperMeta[];
+};
+export type RootStateLike = {
+    profile: ProfileState;
+    meta: MetaStateLike;
+};
+export declare const createProfileState: <T extends RootStateLike>() => {
+    slice: Slice<ProfileState, {
+        logInUser: (state: import("immer/dist/internal.js").WritableDraft<ProfileState>) => void;
+        logOutUser: () => ProfileState;
+        clearAuthError: (state: import("immer/dist/internal.js").WritableDraft<ProfileState>) => void;
+        resetMergeStatus: (state: import("immer/dist/internal.js").WritableDraft<ProfileState>) => void;
+        resetUserData: (state: import("immer/dist/internal.js").WritableDraft<ProfileState>) => void;
+        resetUpdateUsernameError: (state: import("immer/dist/internal.js").WritableDraft<ProfileState>) => void;
+    }, "profile">;
+    thunks: {
+        signMessage: import("@reduxjs/toolkit").AsyncThunk<import("../api/types").ProfileSummary | null, import("./types").SignMessageParams, {
+            state: RootStateLike;
+            rejectValue: string;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchProfileSummary: import("@reduxjs/toolkit").AsyncThunk<import("../api/types").ProfileSummary | null, {
+            username: string;
+            public: boolean;
+        }, {
+            state: RootStateLike;
+            rejectValue: string | null;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchProfileDetails: import("@reduxjs/toolkit").AsyncThunk<import("../api/types").ProfileDetails | null, undefined, {
+            state: T;
+            rejectValue: string | null;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchProfileLeaderboard: import("@reduxjs/toolkit").AsyncThunk<import("../api/types").ProfileLeaderboard[] | null, {
+            username: string;
+            public?: boolean;
+        }, {
+            state: T;
+            rejectValue: string | null;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchPublicLeaderboard: import("@reduxjs/toolkit").AsyncThunk<{
+            leaderboard: import("../api/types").ProfileLeaderboard[] | null;
+            totalPages: number | null;
+        }, import("../api/types").PublicLeaderboardRequest, {
+            state: T;
+            rejectValue: string;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        fetchTopPublicLeaderboard: import("@reduxjs/toolkit").AsyncThunk<import("../api/types").ProfileLeaderboard[] | null, {
+            type: import("../api/types").PublicLeaderboardType;
+        }, {
+            state: T;
+            rejectValue: string;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        updateUsername: import("@reduxjs/toolkit").AsyncThunk<{
+            username: string;
+        }, import("../api/request").UpdateProfileData & {
+            callback: () => void;
+        }, {
+            state: T;
+            rejectValue: string;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        requestLogOutUser: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+            state: RootStateLike;
+            rejectValue: string;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+        setClaim: import("@reduxjs/toolkit").AsyncThunk<import("../api/types").ProfileSummary | null, import("./types").SignMessageParams, {
+            state: RootStateLike;
+            rejectValue: string;
+            dispatch?: import("redux").Dispatch | undefined;
+            extra?: unknown;
+            serializedErrorType?: unknown;
+            pendingMeta?: unknown;
+            fulfilledMeta?: unknown;
+            rejectedMeta?: unknown;
+        }>;
+    };
+};
+export {};

package/dist/store/slice.js

@@ -0,0 +1,230 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { getProfileType } from './helpers';
+import { createProfileThunks } from './thunks';
+export const profileSliceInitialState = {
+    isLoggedIn: false,
+    username: null,
+    profileAuth: {
+        loading: false,
+        error: null,
+        account: null,
+        numberOfRetries: 0,
+        accountMerged: false,
+    },
+    profileSummary: {
+        private: { loading: true, error: null, data: null },
+        public: { loading: true, error: null, data: null },
+    },
+    profileDetails: { loading: true, error: null, data: null },
+    profileLeaderboard: { loading: false, error: null, data: null },
+    publicLeaderboard: { loading: false, error: null, data: null, totalPages: null },
+    topPublicLeaderboard: { loading: false, error: null, data: null },
+    updateUsername: { loading: false, error: null },
+    logOut: {
+        loading: false,
+        error: null,
+    },
+};
+export const createProfileState = () => {
+    const thunks = createProfileThunks();
+    const slice = createSlice({
+        name: 'profile',
+        initialState: profileSliceInitialState,
+        reducers: {
+            logInUser: (state) => {
+                state.isLoggedIn = true;
+            },
+            logOutUser: () => {
+                return profileSliceInitialState;
+            },
+            clearAuthError: (state) => {
+                state.profileAuth.error = null;
+            },
+            resetMergeStatus: (state) => {
+                state.profileAuth.accountMerged = false;
+            },
+            resetUserData: (state) => {
+                state.profileSummary.public = profileSliceInitialState.profileSummary.public;
+            },
+            resetUpdateUsernameError: (state) => {
+                state.updateUsername.error = null;
+            },
+        },
+        extraReducers: (builder) => {
+            builder
+                .addCase(thunks.setClaim.fulfilled, (state, action) => {
+                state.profileSummary.private.data = action.payload;
+            })
+                .addCase(thunks.signMessage.pending, (state, action) => {
+                state.profileAuth.loading = true;
+                state.profileAuth.error = null;
+                state.profileAuth.account = action.meta.arg.account;
+                state.profileAuth.numberOfRetries = 0;
+            })
+                .addCase(thunks.signMessage.rejected, (state, action) => {
+                state.profileAuth.loading = false;
+                state.profileAuth.account = null;
+                state.profileAuth.numberOfRetries = 0;
+                state.profileAuth.error = action.payload ?? null;
+            })
+                .addCase(thunks.signMessage.fulfilled, (state, action) => {
+                state.profileAuth.loading = false;
+                state.profileSummary.private.loading = false;
+                state.profileAuth.error = null;
+                state.profileAuth.account = null;
+                if (action.payload) {
+                    if (state.isLoggedIn) {
+                        state.profileAuth.accountMerged = true;
+                    }
+                    else {
+                        state.isLoggedIn = true;
+                    }
+                    state.profileSummary.private.data = action.payload;
+                    if (action.payload?.username) {
+                        state.username = action.payload?.username;
+                    }
+                    state.profileAuth.numberOfRetries = 0;
+                }
+                else {
+                    state.profileAuth.numberOfRetries += 1;
+                }
+            })
+                .addCase(thunks.fetchProfileSummary.pending, (state, action) => {
+                const { meta: { arg }, } = action;
+                const key = getProfileType(arg.public);
+                state.profileSummary[key].data = null;
+                state.profileSummary[key].loading = true;
+                state.profileSummary[key].error = null;
+            })
+                .addCase(thunks.fetchProfileSummary.fulfilled, (state, action) => {
+                const key = getProfileType(action.meta.arg.public);
+                state.profileSummary[key].loading = false;
+                state.profileSummary[key].error = null;
+                state.profileSummary[key].data = action.payload;
+                if (action.payload?.username && key === 'private') {
+                    state.username = action.payload?.username;
+                }
+            })
+                .addCase(thunks.fetchProfileSummary.rejected, (state, action) => {
+                /**
+                 * In DEV mode react strict will call the action twice.
+                 * We added a check here to make sure if the first request has been cancelled,
+                 * we don't update the state in between of these two requests.
+                 */
+                if (!action.payload || action.error.name === 'AbortError') {
+                    return;
+                }
+                const key = getProfileType(action.meta.arg.public);
+                state.profileSummary[key].loading = false;
+                state.profileSummary[key].error =
+                    typeof action.payload === 'string' ? action.payload : null;
+                state.profileSummary[key].data = null;
+            })
+                .addCase(thunks.fetchProfileDetails.pending, (state) => {
+                state.profileDetails.data = null;
+                state.profileDetails.loading = true;
+                state.profileDetails.error = null;
+            })
+                .addCase(thunks.fetchProfileDetails.fulfilled, (state, action) => {
+                state.profileDetails.loading = false;
+                state.profileDetails.error = null;
+                state.profileDetails.data = action.payload;
+            })
+                .addCase(thunks.fetchProfileDetails.rejected, (state, action) => {
+                /**
+                 * In DEV mode react strict will call the action twice.
+                 * We added a check here to make sure if the first request has been cancelled,
+                 * we don't update the state in between of these two requests.
+                 */
+                if (action.error.name === 'AbortError') {
+                    return;
+                }
+                state.profileDetails.loading = false;
+                state.profileDetails.error = action.payload ?? null;
+                state.profileDetails.data = null;
+            })
+                .addCase(thunks.fetchProfileLeaderboard.pending, (state) => {
+                state.profileLeaderboard.data = null;
+                state.profileLeaderboard.loading = true;
+                state.profileLeaderboard.error = null;
+            })
+                .addCase(thunks.fetchProfileLeaderboard.fulfilled, (state, action) => {
+                state.profileLeaderboard.loading = false;
+                state.profileLeaderboard.error = null;
+                state.profileLeaderboard.data = action.payload;
+            })
+                .addCase(thunks.fetchProfileLeaderboard.rejected, (state, action) => {
+                if (!action.payload) {
+                    return;
+                }
+                state.profileLeaderboard.loading = false;
+                state.profileLeaderboard.error = action.payload ?? null;
+            })
+                .addCase(thunks.fetchPublicLeaderboard.pending, (state, action) => {
+                state.publicLeaderboard.loading = true;
+                state.publicLeaderboard.error = null;
+                if (action.meta.arg.page === 0) {
+                    state.topPublicLeaderboard.loading = true;
+                    state.topPublicLeaderboard.error = null;
+                }
+            })
+                .addCase(thunks.fetchPublicLeaderboard.fulfilled, (state, action) => {
+                state.publicLeaderboard.loading = false;
+                state.publicLeaderboard.error = null;
+                state.publicLeaderboard.data = action.payload.leaderboard;
+                state.publicLeaderboard.totalPages = action.payload.totalPages;
+                if (action.meta.arg.page === 0) {
+                    state.topPublicLeaderboard.loading = false;
+                    state.topPublicLeaderboard.error = null;
+                    state.topPublicLeaderboard.data = action.payload.leaderboard;
+                }
+            })
+                .addCase(thunks.fetchPublicLeaderboard.rejected, (state, action) => {
+                state.publicLeaderboard.loading = false;
+                state.publicLeaderboard.error = action.payload ?? null;
+                if (action.meta.arg.page === 0) {
+                    state.topPublicLeaderboard.loading = false;
+                    state.topPublicLeaderboard.error = action.payload ?? null;
+                }
+            })
+                .addCase(thunks.fetchTopPublicLeaderboard.pending, (state) => {
+                state.topPublicLeaderboard.loading = true;
+                state.topPublicLeaderboard.error = null;
+            })
+                .addCase(thunks.fetchTopPublicLeaderboard.fulfilled, (state, action) => {
+                state.topPublicLeaderboard.loading = false;
+                state.topPublicLeaderboard.error = null;
+                state.topPublicLeaderboard.data = action.payload;
+            })
+                .addCase(thunks.fetchTopPublicLeaderboard.rejected, (state, action) => {
+                state.topPublicLeaderboard.loading = false;
+                state.topPublicLeaderboard.error = action.payload ?? null;
+            })
+                .addCase(thunks.updateUsername.pending, (state) => {
+                state.updateUsername.loading = true;
+                state.updateUsername.error = null;
+            })
+                .addCase(thunks.updateUsername.fulfilled, (state, action) => {
+                state.updateUsername.loading = false;
+                state.username = action.payload.username;
+            })
+                .addCase(thunks.updateUsername.rejected, (state, action) => {
+                state.updateUsername.loading = false;
+                state.updateUsername.error = action.payload ?? null;
+            })
+                .addCase(thunks.requestLogOutUser.pending, (state) => {
+                state.logOut.loading = true;
+                state.logOut.error = null;
+            })
+                .addCase(thunks.requestLogOutUser.fulfilled, () => profileSliceInitialState)
+                .addCase(thunks.requestLogOutUser.rejected, (state, action) => {
+                state.logOut.loading = false;
+                state.logOut.error = action.payload ?? null;
+            });
+        },
+    });
+    return {
+        slice,
+        thunks,
+    };
+};

package/dist/store/thunks.d.ts

@@ -0,0 +1,153 @@
+import type { RootStateLike } from './slice';
+import type { SignMessageParams } from './types';
+import type { ProfileDetails, ProfileLeaderboard, ProfileSummary, PublicLeaderboardRequest, PublicLeaderboardType, UpdateProfileData } from '../api/mod';
+export declare function createSignMessage<T extends RootStateLike>(): import("@reduxjs/toolkit").AsyncThunk<ProfileSummary | null, SignMessageParams, {
+    state: T;
+    rejectValue: string;
+    dispatch?: import("redux").Dispatch | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare function createFetchProfileSummary<T extends RootStateLike>(): import("@reduxjs/toolkit").AsyncThunk<ProfileSummary | null, {
+    username: string;
+    public: boolean;
+}, {
+    state: T;
+    rejectValue: string | null;
+    dispatch?: import("redux").Dispatch | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare function createSetClaim<T extends RootStateLike>(): import("@reduxjs/toolkit").AsyncThunk<ProfileSummary | null, SignMessageParams, {
+    state: T;
+    rejectValue: string;
+    dispatch?: import("redux").Dispatch | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare function createRequestLogOutUser<T extends RootStateLike>(): import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: T;
+    rejectValue: string;
+    dispatch?: import("redux").Dispatch | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare function createProfileThunks<T extends RootStateLike>(): {
+    signMessage: import("@reduxjs/toolkit").AsyncThunk<ProfileSummary | null, SignMessageParams, {
+        state: RootStateLike;
+        rejectValue: string;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    fetchProfileSummary: import("@reduxjs/toolkit").AsyncThunk<ProfileSummary | null, {
+        username: string;
+        public: boolean;
+    }, {
+        state: RootStateLike;
+        rejectValue: string | null;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    fetchProfileDetails: import("@reduxjs/toolkit").AsyncThunk<ProfileDetails | null, undefined, {
+        state: T;
+        rejectValue: string | null;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    fetchProfileLeaderboard: import("@reduxjs/toolkit").AsyncThunk<ProfileLeaderboard[] | null, {
+        username: string;
+        public?: boolean;
+    }, {
+        state: T;
+        rejectValue: string | null;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    fetchPublicLeaderboard: import("@reduxjs/toolkit").AsyncThunk<{
+        leaderboard: ProfileLeaderboard[] | null;
+        totalPages: number | null;
+    }, PublicLeaderboardRequest, {
+        state: T;
+        rejectValue: string;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    fetchTopPublicLeaderboard: import("@reduxjs/toolkit").AsyncThunk<ProfileLeaderboard[] | null, {
+        type: PublicLeaderboardType;
+    }, {
+        state: T;
+        rejectValue: string;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    updateUsername: import("@reduxjs/toolkit").AsyncThunk<{
+        username: string;
+    }, UpdateProfileData & {
+        callback: () => void;
+    }, {
+        state: T;
+        rejectValue: string;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    requestLogOutUser: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+        state: RootStateLike;
+        rejectValue: string;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+    setClaim: import("@reduxjs/toolkit").AsyncThunk<ProfileSummary | null, SignMessageParams, {
+        state: RootStateLike;
+        rejectValue: string;
+        dispatch?: import("redux").Dispatch | undefined;
+        extra?: unknown;
+        serializedErrorType?: unknown;
+        pendingMeta?: unknown;
+        fulfilledMeta?: unknown;
+        rejectedMeta?: unknown;
+    }>;
+};