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

package/auth/entitlements.d.ts

@@ -1,16 +1,35 @@
-import { Entitlement, EntitledToOptions } from '@frontegg/redux-store';
+import { CustomAttributes } from '@frontegg/entitlements-javascript-commons';
+import { EntitledToOptions, Entitlement } from '@frontegg/redux-store';
 /**
-  @param key
-  @returns if the user is entitled to the given feature. Attaching the justification if not
-*/
-export declare const useFeatureEntitlements: (key: string) => Entitlement;
+ @param key feature key
+ @param customAttributes user attributes
+ @returns if the user is entitled to the given feature and attributes. Attaching the justification if not
+ */
+export declare const useFeatureEntitlements: (key: string, customAttributes?: Record<string, string | number | boolean | Date> | undefined) => Entitlement;
 /**
-  @param key
-  @returns if the user is entitled to the given permission. Attaching the justification if not
-*/
-export declare const usePermissionEntitlements: (key: string) => Entitlement;
+ @param key permission key
+ @param customAttributes user attributes
+ @returns if the user is entitled to the given permission and attributes. Attaching the justification if not
+ */
+export declare const usePermissionEntitlements: (key: string, customAttributes?: Record<string, string | number | boolean | Date> | undefined) => Entitlement;
 /**
-  @param entitledToOptions including permission or feature key
-  @returns if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
-*/
-export declare const useEntitlements: (options: EntitledToOptions) => Entitlement;
+ @param entitledToOptions including permission or feature key
+ @param customAttributes user attributes
+ @returns if the user is entitled to the given feature or permission and attributes (check only one). Attaching the justification if not
+ */
+export declare const useEntitlements: (options: EntitledToOptions, customAttributes?: Record<string, string | number | boolean | Date> | undefined) => Entitlement;
+/**
+ @param entitledToOptions including permission or feature key
+ @returns an action your can use to detect if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
+ */
+export declare const useEntitlementsActions: () => {
+    isEntitledTo: (options: EntitledToOptions, customAttributes?: Record<string, string | number | boolean | Date> | undefined) => Entitlement;
+};
+/**
+ @returns if the option to use entitlements is enabled
+ */
+export declare const useEntitlementsOptions: () => {
+    isEntitlementsEnabled: boolean;
+    isEntitledTo: (options: EntitledToOptions, customAttributes?: Record<string, string | number | boolean | Date> | undefined) => Entitlement;
+    verifyIsEntitledFF: boolean;
+};

package/auth/entitlements.js

@@ -1,36 +1,131 @@
-import { getPermissionEntitlements, getFeatureEntitlements, getEntitlements } from '@frontegg/redux-store';
-import { useAuth } from './hooks';
+import { FeatureFlags, USE_ENTITLEMENTS_V2_ENDPOINT_FF } from '@frontegg/rest-api';
+import { useAuthUserOrNull } from './hooks';
+import { useMemo } from 'react';
+import { useRootState, useShadowDom } from '../common';
+import { useFeatureFlags } from '../flags';
+import { useStore } from '../FronteggStoreContext';
+import { useSnapshot } from '../useSnapshot';
+import { getEntitlements, getFeatureEntitlements, getPermissionEntitlements } from '@frontegg/redux-store';
 
 /**
  * @returns entitlemenets state as stored in the user
  */
-const useEntitlementsState = () => useAuth(({
-  user
-}) => user == null ? void 0 : user.entitlements);
+const useEntitlementsState = () => {
+  var _useSnapshot$user$ent, _useSnapshot$user;
+  const state = useStore().store.auth;
+  return (_useSnapshot$user$ent = (_useSnapshot$user = useSnapshot(state).user) == null ? void 0 : _useSnapshot$user.entitlements) != null ? _useSnapshot$user$ent : {};
+};
 
 /**
-  @param key
-  @returns if the user is entitled to the given feature. Attaching the justification if not
-*/
-export const useFeatureEntitlements = key => {
-  const entitlements = useEntitlementsState();
-  return getFeatureEntitlements(entitlements, key);
+ * @returns user state
+ */
+const useUserState = () => {
+  return useAuthUserOrNull() || undefined;
 };
 
 /**
-  @param key
-  @returns if the user is entitled to the given permission. Attaching the justification if not
-*/
-export const usePermissionEntitlements = key => {
+ * @param customAttributes user attributes
+ * @returns is entitled query data including: entitltments state, final attributes (consumer and frontegg) and API version to use
+ */
+const useEntitlementsQueryData = customAttributes => {
+  const user = useUserState();
   const entitlements = useEntitlementsState();
-  return getPermissionEntitlements(entitlements, key);
+  const {
+    appName
+  } = useRootState();
+  const [useEntitlementsV2] = FeatureFlags.getFeatureFlags([USE_ENTITLEMENTS_V2_ENDPOINT_FF], appName);
+  const attributes = {
+    custom: customAttributes,
+    jwt: user
+  };
+  return {
+    entitlements,
+    attributes,
+    isV2: useEntitlementsV2
+  };
 };
 
 /**
-  @param entitledToOptions including permission or feature key
-  @returns if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
-*/
-export const useEntitlements = options => {
+ @param key feature key
+ @param customAttributes user attributes
+ @returns if the user is entitled to the given feature and attributes. Attaching the justification if not
+ */
+export const useFeatureEntitlements = (key, customAttributes) => {
+  const {
+    entitlements,
+    attributes,
+    isV2
+  } = useEntitlementsQueryData(customAttributes);
+  return getFeatureEntitlements(entitlements, key, attributes, isV2);
+};
+
+/**
+ @param key permission key
+ @param customAttributes user attributes
+ @returns if the user is entitled to the given permission and attributes. Attaching the justification if not
+ */
+export const usePermissionEntitlements = (key, customAttributes) => {
+  const {
+    entitlements,
+    attributes,
+    isV2
+  } = useEntitlementsQueryData(customAttributes);
+  return getPermissionEntitlements(entitlements, key, attributes, isV2);
+};
+
+/**
+ @param entitledToOptions including permission or feature key
+ @param customAttributes user attributes
+ @returns if the user is entitled to the given feature or permission and attributes (check only one). Attaching the justification if not
+ */
+export const useEntitlements = (options, customAttributes) => {
+  const {
+    entitlements,
+    attributes,
+    isV2
+  } = useEntitlementsQueryData(customAttributes);
+  return getEntitlements(entitlements, options, attributes, isV2);
+};
+
+/**
+ @param entitledToOptions including permission or feature key
+ @returns an action your can use to detect if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
+ */
+export const useEntitlementsActions = () => {
+  // this code is duplicated because React is yelling when using useEntitlementsQueryData inside the isEntitledTo function because it's not a hook
+  const user = useUserState();
   const entitlements = useEntitlementsState();
-  return getEntitlements(entitlements, options);
+  const {
+    appName
+  } = useRootState();
+  const [useEntitlementsV2] = FeatureFlags.getFeatureFlags([USE_ENTITLEMENTS_V2_ENDPOINT_FF], appName);
+  return useMemo(() => ({
+    isEntitledTo: (options, customAttributes) => {
+      const attributes = {
+        custom: customAttributes,
+        jwt: user
+      };
+      return getEntitlements(entitlements, options, attributes, useEntitlementsV2);
+    }
+  }), [user, entitlements, useEntitlementsV2]);
+};
+
+/**
+ @returns if the option to use entitlements is enabled
+ */
+export const useEntitlementsOptions = () => {
+  var _entitlementsOptions$;
+  const {
+    entitlementsOptions
+  } = useShadowDom();
+  const isEntitlementsEnabled = (_entitlementsOptions$ = entitlementsOptions == null ? void 0 : entitlementsOptions.enabled) != null ? _entitlementsOptions$ : false;
+  const {
+    isEntitledTo
+  } = useEntitlementsActions();
+  const [verifyIsEntitledFF] = useFeatureFlags(['admin-portal-use-is-entitled']);
+  return {
+    isEntitlementsEnabled,
+    isEntitledTo,
+    verifyIsEntitledFF
+  };
 };

package/auth/forgotPassword.d.ts

@@ -1,5 +1,3 @@
 import { ForgotPasswordState, ForgotPasswordActions } from '@frontegg/redux-store';
-export declare type ForgotPasswordStateMapper<S> = (state: ForgotPasswordState) => S;
 export declare function useForgotPasswordState(): ForgotPasswordState;
-export declare function useForgotPasswordState<S>(stateMapper: ForgotPasswordStateMapper<S>): S;
 export declare const useForgotPasswordActions: () => ForgotPasswordActions;

package/auth/forgotPassword.js

@@ -1,7 +1,9 @@
-import { forgotPasswordReducers, forgotPasswordActions } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useForgotPasswordState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'forgotPasswordState');
+import { useStore } from '../FronteggStoreContext';
+import { useSnapshot } from '../useSnapshot';
+export function useForgotPasswordState() {
+  const state = useStore().store.auth.forgotPasswordState;
+  return useSnapshot(state);
 }
-export const useForgotPasswordActions = () => reducerActionsGenerator(forgotPasswordActions, forgotPasswordReducers);
+export const useForgotPasswordActions = () => {
+  return useStore().stateActions.auth.forgotPasswordActions;
+};

package/auth/groups.d.ts

@@ -1,9 +1,5 @@
 import { GroupsState, GroupsActions, GroupsDialogsState, GroupsDialogsActions } from '@frontegg/redux-store';
-export declare type GroupsStateMapper<S> = (state: GroupsState) => S;
 export declare function useGroupsState(): GroupsState;
-export declare function useGroupsState<S>(stateMapper: GroupsStateMapper<S>): S;
 export declare const useGroupsActions: () => GroupsActions;
-export declare type GroupsDialogsStateMapper<S> = (state: GroupsDialogsState) => S;
 export declare function useGroupsDialogsState(): GroupsDialogsState;
-export declare function useGroupsDialogsState<S>(stateMapper: GroupsDialogsStateMapper<S>): S;
 export declare const useGroupsDialogsActions: () => GroupsDialogsActions;

package/auth/groups.js

@@ -1,15 +1,14 @@
-import { groupsActions, groupsReducers, groupsDialogsActions, groupsDialogsReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useGroupsState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'groupsState');
+import { useStore } from '../FronteggStoreContext';
+import { useSnapshot } from '../useSnapshot';
+export function useGroupsState() {
+  return useSnapshot(useStore().store.auth.groupsState);
 }
-export const useGroupsActions = () => reducerActionsGenerator(groupsActions, groupsReducers);
-
-//dialogs
-
-const defaultDialogsMapper = state => state;
-export function useGroupsDialogsState(stateMapper = defaultDialogsMapper) {
-  return stateHookGenerator(stateMapper, 'groupsDialogsState');
+export const useGroupsActions = () => {
+  return useStore().stateActions.auth.groupsActions;
+};
+export function useGroupsDialogsState() {
+  return useSnapshot(useStore().store.auth.groupsDialogsState);
 }
-export const useGroupsDialogsActions = () => reducerActionsGenerator(groupsDialogsActions, groupsDialogsReducers);
+export const useGroupsDialogsActions = () => {
+  return useStore().stateActions.auth.groupsDialogsActions;
+};

package/auth/hooks.d.ts

@@ -1,14 +1,27 @@
-import { CaseReducerActions, SliceCaseReducers } from '@frontegg/redux-store';
-import { AuthActions, AuthPageRoutes, AuthState, User } from '@frontegg/redux-store';
+import { AuthActions, AuthState } from '@frontegg/redux-store';
 import { RedirectOptions } from '@frontegg/rest-api';
+import { AuthPageRoutes, User } from '@frontegg/redux-store';
 export declare type AuthMapper = {
     state: (state: AuthState) => any;
     actions: (actions: AuthActions) => any;
 };
-export declare type StateHookFunction<T> = (() => T) & (<S extends {}>(mapper: (state: T) => S) => S);
 export declare type AuthStateMapper<S> = (state: AuthState) => S;
+/**
+ * Use this `frontegg` hook function to obtain the complete authentication state, if it exists.
+ *
+ * ```jsx
+ * export const MyFunctionComponent = () => {
+ *   const { isAuthenticated, user } = useAuth();
+ *
+ *   return isAuthenticated ? <div>Hello, User {user.name}</div> : null;
+ * }
+ * ```
+ *
+ * You can also utilize other `frontegg` hooks like `useAuthUser` to specifically retrieve the user and redirect to the login page if necessary, `useAuthUserOrNull` to get the user if available, and `useIsAuthenticated` for checking authentication status.
+ */
 export declare function useAuth(): AuthState;
 export declare function useAuth<S>(stateMapper: AuthStateMapper<S>): S;
+export declare function useAuthState(): AuthState;
 /**
  * ```jsx
  * export const MyFunctionComponent = () => {
@@ -24,9 +37,24 @@ export declare function useAuth<S>(stateMapper: AuthStateMapper<S>): S;
  * }
  * ```
  *
- * use this frontegg hook function to get if user is "Authenticated"
+ /**
+ * Use this frontegg hook function to redirect the user to the login page when in hosted login mode.
+ * If the user is already authenticated, this method will direct the user to the store, and you can retrieve user information using the `useAuthUserOrNull` method.
+ *
+ * To ensure the user is available on the first page load when authenticated, configure this option in your `FronteggProvider`:
+ * `authOptions`:
+ *   `hostedLoginOptions`:
+ *     `loadUserOnFirstLoad: true`
+ *
+ * When using this option, you can have the user on the first load, and you can control when the user is redirected to the login page by using `loginWithRedirect`.
  */
-export declare const useLoginWithRedirect: () => AuthActions['requestHostedLoginAuthorize'];
+export declare const useLoginWithRedirect: () => (additionalParams?: Record<string, string> | undefined) => Promise<void>;
+export declare const useLoginWithRedirectV2: () => (payload?: {
+    additionalParams?: Record<string, string> | undefined;
+    shouldRedirectToLogin?: boolean | undefined;
+    firstTime?: boolean | undefined;
+    loginDirectAction?: import("@frontegg/redux-store").LoginDirectAction | undefined;
+} | undefined) => Promise<void>;
 export declare const useAuthActions: () => AuthActions;
 export declare const useOnRedirectTo: () => (path: string, opts?: RedirectOptions | undefined) => void;
 export declare const useAuthRoutes: () => AuthPageRoutes;
@@ -49,14 +77,18 @@ export declare const useIsAuthenticated: () => boolean;
  * }
  * ```
  *
- * use this frontegg hook function to get the authenticated user
- * the return user is null if not authenticated
+ * Use this `frontegg` hook function to obtain the authenticated user. If the user is not authenticated, this method will immediately redirect the user to the login page. (Primarily intended for embedded mode usage)
+ * To prevent this immediate redirection behavior, use the `useAuthUserOrNull` method.
  */
 export declare const useAuthUser: () => User;
-export declare const useAuthUserOrNull: () => User | null;
 /**
- * hooks helpers
+ * ```jsx
+ * export const MyFunctionComponent = () => {
+ *   const user = useAuthUserOrNull();
+ *   return user ? <div>Hello {user.name}!</div> : <div>Hello Guest!</div>
+ * }
+ * ```
+ *
+ * Use this `frontegg` hook function to retrieve the authenticated user. If the user is not authenticated, this hook will return null. To redirect the user to the login page in case they are not authenticated, use the `useAuthUser` method.
  */
-export declare const sliceReducerActionsBy: <T extends SliceCaseReducers<any>>(reducer: T) => CaseReducerActions<T>;
-export declare const stateHookGenerator: (stateMapper: any, subState: keyof AuthState, enableMapperFalsyReturnValue?: boolean) => any;
-export declare const reducerActionsGenerator: (actions: any, reducers: SliceCaseReducers<any>) => any;
+export declare const useAuthUserOrNull: () => User | null;

package/auth/hooks.js

@@ -1,17 +1,34 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { useContext, useMemo } from 'react';
-import { bindActionCreators } from '@frontegg/redux-store';
-import { authActions, authStoreName } from '@frontegg/redux-store';
-import { shallowEqual } from 'react-redux';
-import { useSelector, useDispatch } from '../FronteggStoreContext';
+import { useContext } from 'react';
 import { ContextHolder } from '@frontegg/rest-api';
-import { ShadowDomContext } from '../common';
+import { FronteggStoreContext, useStore } from '../FronteggStoreContext';
+import { useSnapshot } from '../useSnapshot';
 const defaultMapper = {
   state: state => state,
   actions: actions => actions
 };
+
+/**
+ * Use this `frontegg` hook function to obtain the complete authentication state, if it exists.
+ *
+ * ```jsx
+ * export const MyFunctionComponent = () => {
+ *   const { isAuthenticated, user } = useAuth();
+ *
+ *   return isAuthenticated ? <div>Hello, User {user.name}</div> : null;
+ * }
+ * ```
+ *
+ * You can also utilize other `frontegg` hooks like `useAuthUser` to specifically retrieve the user and redirect to the login page if necessary, `useAuthUserOrNull` to get the user if available, and `useIsAuthenticated` for checking authentication status.
+ */
+
 export function useAuth(stateMapper = defaultMapper.state) {
-  return useSelector(state => stateMapper(state[authStoreName]), shallowEqual);
+  const state = useStore().store.auth;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return stateMapper(useSnapshot(state));
+}
+export function useAuthState() {
+  const state = useStore().store.auth;
+  return useSnapshot(state);
 }
 
 /**
@@ -29,22 +46,39 @@ export function useAuth(stateMapper = defaultMapper.state) {
  * }
  * ```
  *
- * use this frontegg hook function to get if user is "Authenticated"
+ /**
+ * Use this frontegg hook function to redirect the user to the login page when in hosted login mode.
+ * If the user is already authenticated, this method will direct the user to the store, and you can retrieve user information using the `useAuthUserOrNull` method.
+ *
+ * To ensure the user is available on the first page load when authenticated, configure this option in your `FronteggProvider`:
+ * `authOptions`:
+ *   `hostedLoginOptions`:
+ *     `loadUserOnFirstLoad: true`
+ *
+ * When using this option, you can have the user on the first load, and you can control when the user is redirected to the login page by using `loginWithRedirect`.
  */
 export const useLoginWithRedirect = () => {
-  const dispatch = useDispatch();
-  return useMemo(() => bindActionCreators(authActions.requestHostedLoginAuthorize, dispatch), [authActions.requestHostedLoginAuthorize]);
+  const {
+    actions
+  } = useContext(FronteggStoreContext);
+  return actions.requestHostedLoginAuthorize;
+};
+export const useLoginWithRedirectV2 = () => {
+  const {
+    actions
+  } = useContext(FronteggStoreContext);
+  return actions.requestHostedLoginAuthorizeV2;
 };
 export const useAuthActions = () => {
-  const dispatch = useDispatch();
-  return useMemo(() => bindActionCreators(authActions, dispatch), [authActions]);
+  return useStore().actions;
 };
 export const useOnRedirectTo = () => {
-  var _context$onRedirectTo;
-  const context = useContext(ShadowDomContext);
-  return (_context$onRedirectTo = context == null ? void 0 : context.onRedirectTo) != null ? _context$onRedirectTo : ContextHolder.onRedirectTo;
+  const {
+    onRedirectTo
+  } = useAuth();
+  return onRedirectTo || ContextHolder.onRedirectTo;
 };
-export const useAuthRoutes = () => useAuth(state => _extends({}, state.routes));
+export const useAuthRoutes = () => useAuthState().routes;
 
 /**
  * ```jsx
@@ -56,11 +90,12 @@ export const useAuthRoutes = () => useAuth(state => _extends({}, state.routes));
  *
  * use this frontegg hook function to get if user is "Authenticated"
  */
-export const useIsAuthenticated = () => useSelector(({
-  [authStoreName]: {
+export const useIsAuthenticated = () => {
+  const {
     isAuthenticated
-  }
-}) => isAuthenticated, shallowEqual);
+  } = useSnapshot(useStore().store.auth);
+  return isAuthenticated;
+};
 
 /**
  * ```jsx
@@ -70,8 +105,8 @@ export const useIsAuthenticated = () => useSelector(({
  * }
  * ```
  *
- * use this frontegg hook function to get the authenticated user
- * the return user is null if not authenticated
+ * Use this `frontegg` hook function to obtain the authenticated user. If the user is not authenticated, this method will immediately redirect the user to the login page. (Primarily intended for embedded mode usage)
+ * To prevent this immediate redirection behavior, use the `useAuthUserOrNull` method.
  */
 export const useAuthUser = () => {
   const {
@@ -79,7 +114,9 @@ export const useAuthUser = () => {
     customLoginUrl
   } = useAuthRoutes();
   const onRedirectTo = useOnRedirectTo();
-  const user = useAuthUserOrNull();
+  const {
+    user
+  } = useAuth();
   const isSSR = typeof window === 'undefined';
   const noUser = {};
   if (user == null && !isSSR) {
@@ -90,46 +127,20 @@ export const useAuthUser = () => {
   }
   return user || noUser;
 };
+
+/**
+ * ```jsx
+ * export const MyFunctionComponent = () => {
+ *   const user = useAuthUserOrNull();
+ *   return user ? <div>Hello {user.name}!</div> : <div>Hello Guest!</div>
+ * }
+ * ```
+ *
+ * Use this `frontegg` hook function to retrieve the authenticated user. If the user is not authenticated, this hook will return null. To redirect the user to the login page in case they are not authenticated, use the `useAuthUser` method.
+ */
 export const useAuthUserOrNull = () => {
   const {
     user
-  } = useSelector(({
-    [authStoreName]: {
-      user
-    }
-  }) => ({
-    user
-  }), shallowEqual);
+  } = useAuth();
   return user || null;
-};
-
-/**
- * hooks helpers
- */
-export const sliceReducerActionsBy = reducer => {
-  const reducerKeys = Object.keys(reducer);
-  const reducerActions = reducerKeys.map(key => ({
-    [key]: authActions[key]
-  }));
-  return reducerActions.reduce((p, n) => _extends({}, p, n), {});
-};
-
-/*
- * enableMapperFalsyReturnValue was added to be backward compatible with all usages
- * the scenario that require enableMapperFalsyReturnValue of true is when the
- * mapper function returns a falsy value then we want to return it as is - it's a valid case like in entitlements (when it's undefined)
- * IMO all usages should be like that
- */
-export const stateHookGenerator = (stateMapper, subState, enableMapperFalsyReturnValue = false) => {
-  return useSelector(state => {
-    const mapperValue = stateMapper == null ? void 0 : stateMapper(state[authStoreName][subState]);
-    if (enableMapperFalsyReturnValue && stateMapper) {
-      return mapperValue;
-    }
-    return mapperValue != null ? mapperValue : state[authStoreName][subState];
-  }, shallowEqual);
-};
-export const reducerActionsGenerator = (actions, reducers) => {
-  const dispatch = useDispatch();
-  return useMemo(() => bindActionCreators(_extends({}, actions, sliceReducerActionsBy(reducers)), dispatch), [dispatch]);
 };

package/auth/impersonate.d.ts

@@ -1,5 +1,3 @@
 import { ImpersonateState, ImpersonateActions } from '@frontegg/redux-store';
-export declare type ImpersonateStateMapper<S> = (state: ImpersonateState) => S;
 export declare function useImpersonateState(): ImpersonateState;
-export declare function useImpersonateState<S>(stateMapper: ImpersonateStateMapper<S>): S;
 export declare const useImpersonateActions: () => ImpersonateActions;

package/auth/impersonate.js

@@ -1,7 +1,8 @@
-import { impersonateActions, impersonateReducers } from '@frontegg/redux-store';
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-const defaultMapper = state => state;
-export function useImpersonateState(stateMapper = defaultMapper) {
-  return stateHookGenerator(stateMapper, 'impersonateState');
+import { useSnapshot } from '../useSnapshot';
+import { useStore } from '../FronteggStoreContext';
+export function useImpersonateState() {
+  return useSnapshot(useStore().store.auth.impersonateState);
 }
-export const useImpersonateActions = () => reducerActionsGenerator(impersonateActions, impersonateReducers);
+export const useImpersonateActions = () => {
+  return useStore().stateActions.auth.impersonateActions;
+};

package/auth/index.d.ts

@@ -1,27 +1,26 @@
-export { useAuth, useAuthActions, useOnRedirectTo, useAuthRoutes, useIsAuthenticated, useAuthUser, useAuthUserOrNull, useLoginWithRedirect, } from './hooks';
+export { useAuthState, useAuth, useAuthActions, useOnRedirectTo, useAuthRoutes, useIsAuthenticated, useAuthUser, useAuthUserOrNull, useLoginWithRedirect, useLoginWithRedirectV2, } from './hooks';
 export * from './acceptInvitation';
 export * from './activateAccount';
+export * from './allAccounts';
 export * from './apiTokens';
+export * from './customLogin';
+export * from './entitlements';
 export * from './forgotPassword';
-export * from './resetPhoneNumber';
+export * from './groups';
+export * from './impersonate';
 export * from './login';
 export * from './mfa';
+export * from './passkeys';
 export * from './profile';
+export * from './provisioning';
+export * from './resetPhoneNumber';
+export * from './roles';
+export * from './sessions';
 export * from './signup';
+export * from './sms';
 export * from './socialLogin';
-export * from './team';
 export * from './sso';
-export * from './security/securityPolicy';
+export * from './stepUp';
+export * from './team';
+export * from './security';
 export * from './tenants';
-export * from './roles';
-export * from './sessions';
-export * from './security/sessionsPolicy';
-export * from './security/restrictions';
-export * from './provisioning';
-export * from './impersonate';
-export * from './passkeys';
-export * from './groups';
-export * from './customLogin';
-export * from './MSP/allAccounts';
-export * from './entitlements';
-export * from './security/securityCenter';

package/auth/index.js

@@ -1,27 +1,26 @@
-export { useAuth, useAuthActions, useOnRedirectTo, useAuthRoutes, useIsAuthenticated, useAuthUser, useAuthUserOrNull, useLoginWithRedirect } from './hooks';
+export { useAuthState, useAuth, useAuthActions, useOnRedirectTo, useAuthRoutes, useIsAuthenticated, useAuthUser, useAuthUserOrNull, useLoginWithRedirect, useLoginWithRedirectV2 } from './hooks';
 export * from './acceptInvitation';
 export * from './activateAccount';
+export * from './allAccounts';
 export * from './apiTokens';
+export * from './customLogin';
+export * from './entitlements';
 export * from './forgotPassword';
-export * from './resetPhoneNumber';
+export * from './groups';
+export * from './impersonate';
 export * from './login';
 export * from './mfa';
+export * from './passkeys';
 export * from './profile';
+export * from './provisioning';
+export * from './resetPhoneNumber';
+export * from './roles';
+export * from './sessions';
 export * from './signup';
+export * from './sms';
 export * from './socialLogin';
-export * from './team';
 export * from './sso';
-export * from './security/securityPolicy';
-export * from './tenants';
-export * from './roles';
-export * from './sessions';
-export * from './security/sessionsPolicy';
-export * from './security/restrictions';
-export * from './provisioning';
-export * from './impersonate';
-export * from './passkeys';
-export * from './groups';
-export * from './customLogin';
-export * from './MSP/allAccounts';
-export * from './entitlements';
-export * from './security/securityCenter';
+export * from './stepUp';
+export * from './team';
+export * from './security';
+export * from './tenants';

package/auth/login.d.ts

@@ -1,5 +1,3 @@
-import { LoginState, LoginActions } from '@frontegg/redux-store';
-export declare type LoginStateMapper<S> = (state: LoginState) => S;
+import type { LoginState, LoginActions } from '@frontegg/redux-store';
 export declare function useLoginState(): LoginState;
-export declare function useLoginState<S>(stateMapper: LoginStateMapper<S>): S;
 export declare const useLoginActions: () => LoginActions;