@frontegg/react-hooks 7.0.0-alpha.0 → 7.0.0-alpha.2

package/auth/login.js

@@ -1,7 +1,8 @@
-import { loginReducers, loginActions } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useLoginState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'loginState');
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function useLoginState() {
+  return useSnapshot(useStore().store.auth.loginState);
 }
-export const useLoginActions = () => reducerActionsGenerator(loginActions, loginReducers);
+export const useLoginActions = () => {
+  return useStore().stateActions.auth.loginActions;
+};

package/auth/mfa.d.ts

@@ -1,4 +1,4 @@
-import { MfaActions, MFAState } from '@frontegg/redux-store';
+import type { MfaActions, MFAState } from '@frontegg/redux-store';
 declare type AuthMfaStateMapper<S> = (state: MFAState) => S;
 export declare function useMfaState(): MFAState;
 export declare function useMfaState<S>(stateMapper: AuthMfaStateMapper<S>): S;

package/auth/mfa.js

@@ -1,7 +1,16 @@
-import { mfaActions, mfaReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+
+// TODO: remove useless stateMapper, valtio already does this
+
 const defaultMapper = state => state;
+// @deprecated use useMfaState() instead
 export function useMfaState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'mfaState');
+  const {
+    mfaState
+  } = useStore().store.auth;
+  return stateMapper(useSnapshot(mfaState));
 }
-export const useMfaActions = () => reducerActionsGenerator(mfaActions, mfaReducers);
+export const useMfaActions = () => {
+  return useStore().stateActions.auth.mfaActions;
+};

package/auth/passkeys.d.ts

@@ -1,6 +1,3 @@
-import { PasskeysActions, PasskeysState } from '@frontegg/redux-store';
-declare type AuthPasskeysStateMapper<S> = (state: PasskeysState) => S;
+import type { PasskeysActions, PasskeysState } from '@frontegg/redux-store';
 export declare function usePasskeysState(): PasskeysState;
-export declare function usePasskeysState<S>(stateMapper: AuthPasskeysStateMapper<S>): S;
 export declare const usePasskeysActions: () => PasskeysActions;
-export {};

package/auth/passkeys.js

@@ -1,7 +1,8 @@
-import { passkeysActions, passkeysReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function usePasskeysState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'passkeysState');
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function usePasskeysState() {
+  return useSnapshot(useStore().store.auth.passkeysState);
 }
-export const usePasskeysActions = () => reducerActionsGenerator(passkeysActions, passkeysReducers);
+export const usePasskeysActions = () => {
+  return useStore().stateActions.auth.passkeysActions;
+};

package/auth/profile.d.ts

@@ -1,6 +1,4 @@
-import { ProfileActions, ProfileState } from '@frontegg/redux-store';
-export declare const reloadProfileIfNeeded: () => void;
-export declare type ProfileStateMapper<S> = (state: ProfileState) => S;
+import type { ProfileActions, ProfileState } from '@frontegg/redux-store';
 export declare function useProfileState(): ProfileState;
-export declare function useProfileState<S>(stateMapper: ProfileStateMapper<S>): S;
 export declare const useProfileActions: () => ProfileActions;
+export declare const reloadProfileIfNeeded: () => void;

package/auth/profile.js

@@ -1,6 +1,12 @@
 import { useEffect } from 'react';
-import { profileActions, profileReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function useProfileState() {
+  return useSnapshot(useStore().store.auth.profileState);
+}
+export const useProfileActions = () => {
+  return useStore().stateActions.auth.profileActions;
+};
 export const reloadProfileIfNeeded = () => {
   const {
     loading
@@ -11,9 +17,4 @@ export const reloadProfileIfNeeded = () => {
   useEffect(() => {
     !loading && loadProfile();
   }, []);
-};
-const defaultMapper = state => state;
-export function useProfileState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'profileState');
-}
-export const useProfileActions = () => reducerActionsGenerator(profileActions, profileReducers);
+};

package/auth/provisioning.d.ts

@@ -1,5 +1,3 @@
-import { ProvisioningActions, ProvisioningState } from '@frontegg/redux-store';
-export declare type ProvisioningStateMapper<S> = (state: ProvisioningState) => S;
+import type { ProvisioningActions, ProvisioningState } from '@frontegg/redux-store';
 export declare function useProvisioningState(): ProvisioningState;
-export declare function useProvisioningState<S>(stateMapper: ProvisioningStateMapper<S>): S;
 export declare const useProvisioningActions: () => ProvisioningActions;

package/auth/provisioning.js

@@ -1,7 +1,8 @@
-import { provisioningActions, provisioningReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useProvisioningState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'provisioningState');
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function useProvisioningState() {
+  return useSnapshot(useStore().store.auth.provisioningState);
 }
-export const useProvisioningActions = () => reducerActionsGenerator(provisioningActions, provisioningReducers);
+export const useProvisioningActions = () => {
+  return useStore().stateActions.auth.provisioningActions;
+};

package/auth/resetPhoneNumber.d.ts

@@ -1,5 +1,3 @@
-import { ResetPhoneNumberState, ResetPhoneNumberActions } from '@frontegg/redux-store';
-export declare type ResetPhoneNumberStateMapper<S> = (state: ResetPhoneNumberState) => S;
+import type { ResetPhoneNumberState, ResetPhoneNumberActions } from '@frontegg/redux-store';
 export declare function useResetPhoneNumberState(): ResetPhoneNumberState;
-export declare function useResetPhoneNumberState<S>(stateMapper: ResetPhoneNumberStateMapper<S>): S;
 export declare const useResetPhoneNumberActions: () => ResetPhoneNumberActions;

package/auth/resetPhoneNumber.js

@@ -1,7 +1,8 @@
-import { resetPhoneNumberReducers, resetPhoneNumberActions } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useResetPhoneNumberState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'resetPhoneNumberState');
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function useResetPhoneNumberState() {
+  return useSnapshot(useStore().store.auth.resetPhoneNumberState);
 }
-export const useResetPhoneNumberActions = () => reducerActionsGenerator(resetPhoneNumberActions, resetPhoneNumberReducers);
+export const useResetPhoneNumberActions = () => {
+  return useStore().stateActions.auth.resetPhoneNumberActions;
+};

package/auth/roles.d.ts

@@ -1,5 +1,3 @@
-import { RolesActions, RolesState } from '@frontegg/redux-store';
-export declare type RolesStateMapper<S> = (state: RolesState) => S;
+import type { RolesActions, RolesState } from '@frontegg/redux-store';
 export declare function useRolesState(): RolesState;
-export declare function useRolesState<S>(stateMapper: RolesStateMapper<S>): S;
 export declare const useRolesActions: () => RolesActions;

package/auth/roles.js

@@ -1,7 +1,8 @@
-import { rolesReducers, rolesActions } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useRolesState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'rolesState');
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function useRolesState() {
+  return useSnapshot(useStore().store.auth.rolesState);
 }
-export const useRolesActions = () => reducerActionsGenerator(rolesActions, rolesReducers);
+export const useRolesActions = () => {
+  return useStore().stateActions.auth.rolesActions;
+};

package/auth/security/index.d.ts

@@ -0,0 +1,4 @@
+export * from './restrictions';
+export * from './securityCenter';
+export * from './securityPolicy';
+export * from './sessionsPolicy';

package/auth/security/index.js

@@ -0,0 +1,4 @@
+export * from './restrictions';
+export * from './securityCenter';
+export * from './securityPolicy';
+export * from './sessionsPolicy';

package/auth/security/restrictions.d.ts

@@ -1,7 +1,5 @@
 import { RestrictionsActions, RestrictionsState } from '@frontegg/redux-store';
-export declare type RestrictionsStateMapper<S> = (state: RestrictionsState) => S;
 export declare function useRestrictionsState(): RestrictionsState;
-export declare function useRestrictionsState<S>(stateMapper: RestrictionsStateMapper<S>): S;
 export declare const useRestrictionsActions: () => RestrictionsActions;
 export declare const useIpRestrictions: (loadOnMount?: boolean) => {
     loading: boolean;

package/auth/security/restrictions.js

@@ -1,11 +1,13 @@
-import { restrictionsReducers, restrictionsActions } from '@frontegg/redux-store';
 import { useEffect } from 'react';
-import { reducerActionsGenerator, stateHookGenerator } from '../hooks';
-const defaultMapper = state => state;
-export function useRestrictionsState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'restrictionsState');
+import { useStore } from '../../FronteggStoreContext';
+import { useSnapshot } from '../../useSnapshot';
+export function useRestrictionsState() {
+  const state = useStore().store.auth.restrictionsState;
+  return useSnapshot(state);
 }
-export const useRestrictionsActions = () => reducerActionsGenerator(restrictionsActions, restrictionsReducers);
+export const useRestrictionsActions = () => {
+  return useStore().stateActions.auth.restrictionsActions;
+};
 export const useIpRestrictions = (loadOnMount = false) => {
   const {
     loading,
@@ -15,13 +17,12 @@ export const useIpRestrictions = (loadOnMount = false) => {
     pagination,
     totalPages,
     userIpValid
-  } = useRestrictionsState(state => state.ipRestrictions);
+  } = useRestrictionsState().ipRestrictions;
   const {
     loadIpRestrictions
   } = useRestrictionsActions();
   useEffect(() => {
     (loadOnMount || !data) && loadIpRestrictions();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [loadOnMount, loadIpRestrictions]);
   return {
     loading,
@@ -39,13 +40,12 @@ export const useEmailDomainRestrictions = (loadOnMount = false) => {
     data,
     saving,
     error
-  } = useRestrictionsState(state => state.emailDomainRestrictions);
+  } = useRestrictionsState().emailDomainRestrictions;
   const {
     loadEmailDomainRestrictions
   } = useRestrictionsActions();
   useEffect(() => {
     (loadOnMount || !data) && loadEmailDomainRestrictions();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [loadOnMount, loadEmailDomainRestrictions]);
   return {
     loading,

package/auth/security/securityCenter.d.ts

@@ -1,6 +1,3 @@
-import { SecurityCenterActions, SecurityCenterState } from '@frontegg/redux-store';
-declare type AuthSecurityCenterStateMapper<S> = (state: SecurityCenterState) => S;
+import type { SecurityCenterActions, SecurityCenterState } from '@frontegg/redux-store';
 export declare function useSecurityCenterState(): SecurityCenterState;
-export declare function useSecurityCenterState<S>(stateMapper: AuthSecurityCenterStateMapper<S>): S;
 export declare const useSecurityCenterActions: () => SecurityCenterActions;
-export {};

package/auth/security/securityCenter.js

@@ -1,7 +1,9 @@
-import { securityCenterActions, securityCenterReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from '../hooks';
-const defaultMapper = state => state;
-export function useSecurityCenterState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'securityCenterState');
+import { useStore } from '../../FronteggStoreContext';
+import { useSnapshot } from '../../useSnapshot';
+export function useSecurityCenterState() {
+  const state = useStore().store.auth.securityCenterState;
+  return useSnapshot(state);
 }
-export const useSecurityCenterActions = () => reducerActionsGenerator(securityCenterActions, securityCenterReducers);
+export const useSecurityCenterActions = () => {
+  return useStore().stateActions.auth.securityCenterActions;
+};

package/auth/security/securityPolicy.d.ts

@@ -1,17 +1,11 @@
-import { SecurityPolicyActions, SecurityPolicyState } from '@frontegg/redux-store';
+import type { SecurityPolicyActions, SecurityPolicyState } from '@frontegg/redux-store';
 export declare type SecurityPolicyStateMapper<S> = (state: SecurityPolicyState) => S;
 export declare function useSecurityPolicyState(): SecurityPolicyState;
 export declare function useSecurityPolicyState<S>(stateMapper: SecurityPolicyStateMapper<S>): S;
 export declare const useSecurityPolicyActions: () => SecurityPolicyActions;
-export declare const usePublicPolicySettings: (loadOnMount?: boolean) => {
-    loading: boolean;
-    saving: boolean | undefined;
-    error: any;
-    policy: import("@frontegg/rest-api").IVendorConfig | undefined;
+export declare const usePublicPolicySettings: (loadOnMount?: boolean) => import("@frontegg/redux-store").WithStatus & {
+    policy?: import("@frontegg/rest-api").IVendorConfig | undefined;
 };
-export declare const usePublicAuthStrategiesPolicySettings: (loadOnMount?: boolean) => {
-    loading: boolean;
-    saving: boolean | undefined;
-    error: any;
-    policy: import("@frontegg/rest-api").IAuthStrategiesConfig | undefined;
+export declare const usePublicAuthStrategiesPolicySettings: (loadOnMount?: boolean) => import("@frontegg/redux-store").WithStatus & {
+    policy?: import("@frontegg/rest-api").IAuthStrategiesConfig | undefined;
 };

package/auth/security/securityPolicy.js

@@ -1,50 +1,39 @@
-import { securityPolicyActions, securityPolicyReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from '../hooks';
 import { useEffect } from 'react';
+import { useStore } from '../../FronteggStoreContext';
+import { useSnapshot } from '../../useSnapshot';
+
+// TODO: remove useless stateMapper, valtio already does this
+
 const defaultMapper = state => state;
+// @deprecated use useSecurityPolicyState() instead
 export function useSecurityPolicyState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'securityPolicyState');
+  const state = useStore().store.auth.securityPolicyState;
+  return stateMapper(useSnapshot(state));
 }
-export const useSecurityPolicyActions = () => reducerActionsGenerator(securityPolicyActions, securityPolicyReducers);
+export const useSecurityPolicyActions = () => {
+  return useStore().stateActions.auth.securityPolicyActions;
+};
 export const usePublicPolicySettings = (loadOnMount = false) => {
   const {
-    loading,
-    policy,
-    saving,
-    error
-  } = useSecurityPolicyState(state => state.publicPolicy);
+    publicPolicy
+  } = useSecurityPolicyState();
   const {
     loadPublicSecurityPolicy
   } = useSecurityPolicyActions();
   useEffect(() => {
-    (loadOnMount || !policy) && loadPublicSecurityPolicy();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (loadOnMount || !publicPolicy.policy) && loadPublicSecurityPolicy();
   }, [loadOnMount, loadPublicSecurityPolicy]);
-  return {
-    loading,
-    saving,
-    error,
-    policy
-  };
+  return publicPolicy;
 };
 export const usePublicAuthStrategiesPolicySettings = (loadOnMount = false) => {
   const {
-    loading,
-    policy,
-    saving,
-    error
-  } = useSecurityPolicyState(state => state.publicAuthStrategyPolicy);
+    publicAuthStrategyPolicy
+  } = useSecurityPolicyState();
   const {
     loadPublicAuthStrategiesPolicy
   } = useSecurityPolicyActions();
   useEffect(() => {
-    (loadOnMount || !policy) && loadPublicAuthStrategiesPolicy();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (loadOnMount || !publicAuthStrategyPolicy.policy) && loadPublicAuthStrategiesPolicy();
   }, [loadOnMount, loadPublicAuthStrategiesPolicy]);
-  return {
-    loading,
-    saving,
-    error,
-    policy
-  };
+  return publicAuthStrategyPolicy;
 };

package/auth/security/sessionsPolicy.d.ts

@@ -1,5 +1,3 @@
-import { SessionsPolicyState, SessionsPolicyActions } from '@frontegg/redux-store';
-export declare type SessionsPolicyStateMapper<S> = (state: SessionsPolicyState) => S;
+import type { SessionsPolicyState, SessionsPolicyActions } from '@frontegg/redux-store';
 export declare function useSessionsPolicyState(): SessionsPolicyState;
-export declare function useSessionsPolicyState<S>(stateMapper: SessionsPolicyStateMapper<S>): S;
 export declare const useSessionsPolicyActions: () => SessionsPolicyActions;

package/auth/security/sessionsPolicy.js

@@ -1,7 +1,9 @@
-import { sessionsPolicyActions, sessionsPolicyReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from '../hooks';
-const defaultMapper = state => state;
-export function useSessionsPolicyState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'sessionsPolicyState');
+import { useStore } from '../../FronteggStoreContext';
+import { useSnapshot } from '../../useSnapshot';
+export function useSessionsPolicyState() {
+  const state = useStore().store.auth.sessionsPolicyState;
+  return useSnapshot(state);
 }
-export const useSessionsPolicyActions = () => reducerActionsGenerator(sessionsPolicyActions, sessionsPolicyReducers);
+export const useSessionsPolicyActions = () => {
+  return useStore().stateActions.auth.sessionsPolicyActions;
+};

package/auth/sessions.d.ts

@@ -1,5 +1,3 @@
-import { SessionsState, SessionsActions } from '@frontegg/redux-store';
-export declare type SessionsStateMapper<S> = (state: SessionsState) => S;
+import type { SessionsState, SessionsActions } from '@frontegg/redux-store';
 export declare function useSessionsState(): SessionsState;
-export declare function useSessionsState<S>(stateMapper: SessionsStateMapper<S>): S;
 export declare const useSessionsActions: () => SessionsActions;

package/auth/sessions.js

@@ -1,7 +1,8 @@
-import { sessionsActions, sessionsReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useSessionsState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'sessionsState');
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function useSessionsState() {
+  return useSnapshot(useStore().store.auth.sessionsState);
 }
-export const useSessionsActions = () => reducerActionsGenerator(sessionsActions, sessionsReducers);
+export const useSessionsActions = () => {
+  return useStore().stateActions.auth.sessionsActions;
+};

package/auth/signup.d.ts

@@ -1,4 +1,4 @@
-import { SignUpState, SignUpActions } from '@frontegg/redux-store';
+import type { SignUpState, SignUpActions } from '@frontegg/redux-store';
 export declare type SignUpStateMapper<S> = (state: SignUpState) => S;
 export declare function useSignUpState(): SignUpState;
 export declare function useSignUpState<S>(stateMapper: SignUpStateMapper<S>): S;

package/auth/signup.js

@@ -1,7 +1,16 @@
-import { signUpReducers, signUpActions } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+
+// TODO: remove useless stateMapper, valtio already does this
+
 const defaultMapper = state => state;
+// @deprecated use useSignUpState() instead
 export function useSignUpState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'signUpState');
+  const {
+    signUpState
+  } = useStore().store.auth;
+  return stateMapper(useSnapshot(signUpState));
 }
-export const useSignUpActions = () => reducerActionsGenerator(signUpActions, signUpReducers);
+export const useSignUpActions = () => {
+  return useStore().stateActions.auth.signUpActions;
+};

package/auth/sms.d.ts

@@ -0,0 +1,3 @@
+import type { SmsActions, SmsState } from '@frontegg/redux-store';
+export declare function useSmsState(): SmsState;
+export declare const useSmsActions: () => SmsActions;

package/auth/sms.js

@@ -0,0 +1,8 @@
+import { useStore } from '../FronteggStoreContext';
+import { useSnapshot } from '../useSnapshot';
+export function useSmsState() {
+  return useSnapshot(useStore().store.auth.smsState);
+}
+export const useSmsActions = () => {
+  return useStore().stateActions.auth.smsActions;
+};

package/auth/socialLogin.d.ts

@@ -1,4 +1,4 @@
-import { SocialLoginActions, SocialLoginState } from '@frontegg/redux-store';
+import type { SocialLoginActions, SocialLoginState } from '@frontegg/redux-store';
 export declare type SocialLoginStateMapper<S> = (state: SocialLoginState) => S;
 export declare function useSocialLoginState(): SocialLoginState;
 export declare function useSocialLoginState<S>(stateMapper: SocialLoginStateMapper<S>): S;

package/auth/socialLogin.js

@@ -1,7 +1,13 @@
-import { socialLoginsActions, socialLoginsReducer } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
+import { useStore } from '../FronteggStoreContext';
+import { useSnapshot } from '../useSnapshot';
+
+// TODO: remove useless stateMapper, valtio already does this
+
 const defaultMapper = state => state;
+// @deprecated use useSocialLoginState() instead
 export function useSocialLoginState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'socialLoginState');
+  return stateMapper(useSnapshot(useStore().store.auth.socialLoginState));
 }
-export const useSocialLoginActions = () => reducerActionsGenerator(socialLoginsActions, socialLoginsReducer);
+export const useSocialLoginActions = () => {
+  return useStore().stateActions.auth.socialLoginActions;
+};

package/auth/sso.d.ts

@@ -1,4 +1,4 @@
-import { SSOState, SSOActions } from '@frontegg/redux-store';
+import type { SSOState, SSOActions } from '@frontegg/redux-store';
 declare type AuthSSOStateMapper<S> = (state: SSOState) => S;
 export declare function useSSOState(): SSOState;
 export declare function useSSOState<S>(stateMapper: AuthSSOStateMapper<S>): S;

package/auth/sso.js

@@ -1,7 +1,13 @@
-import { ssoActions, ssoReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+
+// TODO: remove useless stateMapper, valtio already does this
+
 const defaultMapper = state => state;
+// @deprecated use useSSOState() instead
 export function useSSOState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'ssoState');
+  return stateMapper(useSnapshot(useStore().store.auth.ssoState));
 }
-export const useSSOActions = () => reducerActionsGenerator(ssoActions, ssoReducers);
+export const useSSOActions = () => {
+  return useStore().stateActions.auth.ssoActions;
+};

package/auth/stepUp.d.ts

@@ -0,0 +1,16 @@
+import { StepUpState, StepUpActions, IsSteppedUpOptions } from '@frontegg/redux-store';
+export declare function useStepUpState(): StepUpState;
+export declare const useStepUpActions: () => StepUpActions;
+/**
+ * @returns max age from the query param as a number or null if not exists
+ */
+export declare const getMaxAgeFromQueryParam: () => number | undefined;
+/**
+ * @returns step up function that redirects to the step up url with the max age param and set the redirect url in the local storage
+ */
+export declare const useStepUp: () => any;
+/**
+ * @param options.maxAge - max age of step up
+ * @returns true when the user is stepped up, false otherwise
+ */
+export declare const useIsSteppedUp: (options?: IsSteppedUpOptions) => boolean;

package/auth/stepUp.js

@@ -0,0 +1,51 @@
+import { STEP_UP_MAX_AGE_PARAM_NAME, getSearchParam, redirectByStepUpUrl, isSteppedUp } from '@frontegg/redux-store';
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+import { useAuth, useAuthRoutes, useAuthUserOrNull, useOnRedirectTo } from './hooks';
+import { useCallback } from 'react';
+export function useStepUpState() {
+  return useSnapshot(useStore().store.auth.stepUpState);
+}
+export const useStepUpActions = () => {
+  return useStore().stateActions.auth.stepUpActions;
+};
+
+/**
+ * @returns max age from the query param as a number or null if not exists
+ */
+export const getMaxAgeFromQueryParam = () => {
+  const str = getSearchParam(STEP_UP_MAX_AGE_PARAM_NAME);
+  return str === undefined ? undefined : +str;
+};
+
+/**
+ * @returns step up function that redirects to the step up url with the max age param and set the redirect url in the local storage
+ */
+export const useStepUp = () => {
+  const {
+    stepUpUrl
+  } = useAuthRoutes();
+  const {
+    hostedLoginBox
+  } = useAuth();
+  const {
+    stepUpHostedLogin
+  } = useStepUpActions();
+  const onRedirectTo = useOnRedirectTo();
+  return useCallback(options => {
+    if (hostedLoginBox) {
+      stepUpHostedLogin(options || {});
+      return;
+    }
+    redirectByStepUpUrl(stepUpUrl, onRedirectTo, options == null ? void 0 : options.maxAge);
+  }, [stepUpUrl, onRedirectTo, stepUpHostedLogin, hostedLoginBox]);
+};
+
+/**
+ * @param options.maxAge - max age of step up
+ * @returns true when the user is stepped up, false otherwise
+ */
+export const useIsSteppedUp = (options = {}) => {
+  const user = useAuthUserOrNull();
+  return isSteppedUp(user, options);
+};

package/auth/team.d.ts

@@ -1,5 +1,13 @@
-import { TeamState, TeamActions } from '@frontegg/redux-store';
+import { TeamActions, TeamState } from '@frontegg/redux-store';
+export declare function useTeamState(): TeamState;
+export declare const useTeamActions: () => TeamActions;
 export declare type AuthTeamStateMapper<S> = (state: TeamState) => S;
+/**
+ * @deprecated use useTeamState instead
+ */
 export declare function useAuthTeamState(): TeamState;
 export declare function useAuthTeamState<S>(stateMapper: AuthTeamStateMapper<S>): S;
+/**
+ * @deprecated use useTeamActions instead
+ */
 export declare const useAuthTeamActions: () => TeamActions;