@frontegg/react-hooks 6.2.4 → 6.4.0

package/FronteggProvider.js

@@ -2,14 +2,12 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 const _excluded = ["authenticatedUrl", "signUpSuccessUrl"];
 import React, { useEffect, useMemo, useRef, useState } from 'react';
-import { Provider as ReduxProvider } from 'react-redux';
 import { createFronteggStore } from '@frontegg/redux-store';
 import { ContextHolder } from '@frontegg/rest-api';
 import { useAuth, useAuthRoutes } from './auth';
-import { FronteggStoreContext } from './FronteggStoreContext';
+import { Provider, FronteggStoreContext } from './FronteggStoreContext';
 import { Fragment as _Fragment } from "react/jsx-runtime";
 import { jsx as _jsx } from "react/jsx-runtime";
-const Provider = ReduxProvider;
 
 const setLoading = loading => {
   const isSSR = typeof document === 'undefined' || typeof window === 'undefined';

package/FronteggStoreContext.d.ts

@@ -1,8 +1,13 @@
-import React from 'react';
-import { ReactReduxContextValue } from 'react-redux';
-export declare const FronteggStoreContext: React.Context<ReactReduxContextValue<any, import("redux").AnyAction>>;
+import React, { FC, ReactNode } from 'react';
+import { ReactReduxContextValue, ProviderProps } from 'react-redux';
+import type { Action, AnyAction } from '@frontegg/redux-store';
+export declare const FronteggStoreContext: React.Context<ReactReduxContextValue<any, AnyAction>>;
 export declare const useSelector: <Selected extends unknown>(selector: (state: any) => Selected, equalityFn?: ((previous: Selected, next: Selected) => boolean) | undefined) => Selected;
-export declare const useDispatch: () => import("redux").Dispatch<import("redux").AnyAction>;
-export declare const useStore: () => import("redux").Store<any, import("redux").AnyAction>;
-export { shallowEqual, connectAdvanced, Provider } from 'react-redux';
+export declare const useDispatch: () => import("redux").Dispatch<AnyAction>;
+export declare const useStore: () => import("redux").Store<any, AnyAction>;
+export { shallowEqual, Provider as ReactReduxProvider } from 'react-redux';
+declare type ProviderWithChildren<A extends Action = AnyAction> = FC<ProviderProps<A> & {
+    children?: ReactNode | undefined;
+}>;
+export declare const Provider: ProviderWithChildren;
 export default FronteggStoreContext;

package/FronteggStoreContext.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { createSelectorHook, createDispatchHook, createStoreHook } from 'react-redux';
+import { createSelectorHook, createDispatchHook, createStoreHook, Provider as ReactReduxProvider } from 'react-redux';
 export const FronteggStoreContext = /*#__PURE__*/React.createContext(null); // @ts-ignore
 
 if (process.env.NODE_ENV !== 'production') {
@@ -9,5 +9,6 @@ if (process.env.NODE_ENV !== 'production') {
 export const useSelector = createSelectorHook(FronteggStoreContext);
 export const useDispatch = createDispatchHook(FronteggStoreContext);
 export const useStore = createStoreHook(FronteggStoreContext);
-export { shallowEqual, connectAdvanced, Provider } from 'react-redux';
+export { shallowEqual, Provider as ReactReduxProvider } from 'react-redux';
+export const Provider = ReactReduxProvider;
 export default FronteggStoreContext;

package/audits/auditLogs.d.ts

@@ -1,5 +1,5 @@
-import { StateHookFunction } from './hooks';
 import { AuditLogsActions, AuditLogsState } from '@frontegg/redux-store';
-export declare type AuditLogsStateMapper<S extends object> = (state: AuditLogsState) => S;
-export declare const useAuditLogsState: StateHookFunction<AuditLogsState>;
+export declare type AuditLogsStateMapper<S> = (state: AuditLogsState) => S;
+export declare function useAuditLogsState(): AuditLogsState;
+export declare function useAuditLogsState<S>(stateMapper: AuditLogsStateMapper<S>): S;
 export declare const useAuditLogsActions: () => AuditLogsActions;

package/audits/auditLogs.js

@@ -1,4 +1,9 @@
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
 import { auditLogsActions, auditLogsReducers } from '@frontegg/redux-store';
-export const useAuditLogsState = stateMapper => stateHookGenerator(stateMapper, 'auditLogsState');
+
+const defaultMapper = state => state;
+
+export function useAuditLogsState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'auditLogsState');
+}
 export const useAuditLogsActions = () => reducerActionsGenerator(auditLogsActions, auditLogsReducers);

package/audits/auditsMetadata.d.ts

@@ -1,5 +1,5 @@
-import { StateHookFunction } from './hooks';
 import { AuditsMetadataActions, AuditsMetadataState } from '@frontegg/redux-store';
-export declare type AuditsMetadataStateMapper<S extends object> = (state: AuditsMetadataState) => S;
-export declare const useAuditsMetadataState: StateHookFunction<AuditsMetadataState>;
+export declare type AuditsMetadataStateMapper<S> = (state: AuditsMetadataState) => S;
+export declare function useAuditsMetadataState(): AuditsMetadataState;
+export declare function useAuditsMetadataState<S>(stateMapper: AuditsMetadataStateMapper<S>): S;
 export declare const useAuditsMetadataActions: () => AuditsMetadataActions;

package/audits/auditsMetadata.js

@@ -1,4 +1,9 @@
-import { reducerActionsGenerator, stateHookGenerator } from './hooks';
 import { auditsMetadataActions, auditsMetadataReducers } from '@frontegg/redux-store';
-export const useAuditsMetadataState = stateMapper => stateHookGenerator(stateMapper, 'auditsMetadataState');
+import { reducerActionsGenerator, stateHookGenerator } from './hooks';
+
+const defaultMapper = state => state;
+
+export function useAuditsMetadataState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'auditsMetadataState');
+}
 export const useAuditsMetadataActions = () => reducerActionsGenerator(auditsMetadataActions, auditsMetadataReducers);

package/audits/hooks.d.ts

@@ -1,8 +1,13 @@
 import { CaseReducerActions, SliceCaseReducers } from '@frontegg/redux-store';
 import { AuditsActions, AuditsState } from '@frontegg/redux-store';
-export declare type AuthStateMapper<S extends object> = (state: AuditsState) => S;
+export declare type AuditsMapper = {
+    state: (state: AuditsState) => any;
+    actions: (actions: AuditsActions) => any;
+};
 export declare type StateHookFunction<T> = (() => T) & (<S extends object>(mapper: (state: T) => S) => S);
-export declare const useAuditsState: <S extends object>(stateMapper?: AuthStateMapper<S> | undefined) => S;
+export declare type AuditsStateMapper<S> = (state: AuditsState) => S;
+export declare function useAuditsState(): AuditsState;
+export declare function useAuditsState<S>(stateMapper: AuditsStateMapper<S>): S;
 export declare const useAuditsActions: () => AuditsActions;
 /**
  * hooks helpers

package/audits/hooks.js

@@ -4,13 +4,13 @@ import { bindActionCreators } from '@frontegg/redux-store';
 import { shallowEqual } from 'react-redux';
 import { useSelector, useDispatch } from '../FronteggStoreContext';
 import { auditsActions, auditsStoreName } from '@frontegg/redux-store';
-export const useAuditsState = stateMapper => {
-  return useSelector(state => {
-    var _stateMapper;
-
-    return (_stateMapper = stateMapper == null ? void 0 : stateMapper(state[auditsStoreName])) != null ? _stateMapper : state[auditsStoreName];
-  }, shallowEqual);
+const defaultMapper = {
+  state: state => state,
+  actions: actions => actions
 };
+export function useAuditsState(stateMapper = defaultMapper.state) {
+  return useSelector(state => stateMapper(state[auditsStoreName]), shallowEqual);
+}
 export const useAuditsActions = () => {
   const dispatch = useDispatch();
   return useMemo(() => bindActionCreators(auditsActions, dispatch), [auditsActions]);
@@ -28,9 +28,9 @@ export const sliceReducerActionsBy = reducer => {
 };
 export const stateHookGenerator = (stateMapper, subState) => {
   return useSelector(state => {
-    var _stateMapper2;
+    var _stateMapper;
 
-    return (_stateMapper2 = stateMapper == null ? void 0 : stateMapper(state[auditsStoreName][subState])) != null ? _stateMapper2 : state[auditsStoreName][subState];
+    return (_stateMapper = stateMapper == null ? void 0 : stateMapper(state[auditsStoreName][subState])) != null ? _stateMapper : state[auditsStoreName][subState];
   }, shallowEqual);
 };
 export const reducerActionsGenerator = (actions, reducers) => {

package/auth/acceptInvitation.d.ts

@@ -1,5 +1,5 @@
 import { AcceptInvitationState, AcceptInvitationActions } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type AcceptInvitationStateMapper<S extends object> = (state: AcceptInvitationState) => S;
-export declare const useAcceptInvitationState: StateHookFunction<AcceptInvitationState>;
+export declare type AcceptInvitationStateMapper<S> = (state: AcceptInvitationState) => S;
+export declare function useAcceptInvitationState(): AcceptInvitationState;
+export declare function useAcceptInvitationState<S>(stateMapper: AcceptInvitationStateMapper<S>): S;
 export declare const useAcceptInvitationActions: () => AcceptInvitationActions;

package/auth/acceptInvitation.js

@@ -1,4 +1,9 @@
 import { acceptInvitationReducers, acceptInvitationActions } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useAcceptInvitationState = stateMapper => stateHookGenerator(stateMapper, 'acceptInvitationState');
+
+const defaultMapper = state => state;
+
+export function useAcceptInvitationState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'acceptInvitationState');
+}
 export const useAcceptInvitationActions = () => reducerActionsGenerator(acceptInvitationActions, acceptInvitationReducers);

package/auth/activateAccount.d.ts

@@ -1,5 +1,5 @@
 import { ActivateAccountState, ActivateAccountActions } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type ActivateAccountStateMapper<S extends object> = (state: ActivateAccountState) => S;
-export declare const useActivateAccountState: StateHookFunction<ActivateAccountState>;
+export declare type ActivateAccountStateMapper<S> = (state: ActivateAccountState) => S;
+export declare function useActivateAccountState(): ActivateAccountState;
+export declare function useActivateAccountState<S>(stateMapper: ActivateAccountStateMapper<S>): S;
 export declare const useActivateAccountActions: () => ActivateAccountActions;

package/auth/activateAccount.js

@@ -1,4 +1,9 @@
 import { activateAccountReducers, activateAccountActions } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useActivateAccountState = stateMapper => stateHookGenerator(stateMapper, 'activateState');
+
+const defaultMapper = state => state;
+
+export function useActivateAccountState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'activateState');
+}
 export const useActivateAccountActions = () => reducerActionsGenerator(activateAccountActions, activateAccountReducers);

package/auth/apiTokens.d.ts

@@ -1,5 +1,5 @@
 import { ApiTokensActions, ApiTokensState } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type ApiTokensStateMapper<S extends object> = (state: ApiTokensState) => S;
-export declare const useApiTokensState: StateHookFunction<ApiTokensState>;
+export declare type ApiTokensStateMapper<S> = (state: ApiTokensState) => S;
+export declare function useApiTokensState(): ApiTokensState;
+export declare function useApiTokensState<S>(stateMapper: ApiTokensStateMapper<S>): S;
 export declare const useApiTokensActions: () => ApiTokensActions;

package/auth/apiTokens.js

@@ -1,4 +1,9 @@
 import { apiTokensActions, apiTokensReducers } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useApiTokensState = stateMapper => stateHookGenerator(stateMapper, 'apiTokensState');
+
+const defaultMapper = state => state;
+
+export function useApiTokensState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'apiTokensState');
+}
 export const useApiTokensActions = () => reducerActionsGenerator(apiTokensActions, apiTokensReducers);

package/auth/forgotPassword.d.ts

@@ -1,5 +1,5 @@
 import { ForgotPasswordState, ForgotPasswordActions } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type ForgotPasswordStateMapper<S extends object> = (state: ForgotPasswordState) => S;
-export declare const useForgotPasswordState: StateHookFunction<ForgotPasswordState>;
+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,4 +1,9 @@
 import { forgotPasswordReducers, forgotPasswordActions } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useForgotPasswordState = stateMapper => stateHookGenerator(stateMapper, 'forgotPasswordState');
+
+const defaultMapper = state => state;
+
+export function useForgotPasswordState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'forgotPasswordState');
+}
 export const useForgotPasswordActions = () => reducerActionsGenerator(forgotPasswordActions, forgotPasswordReducers);

package/auth/hooks.d.ts

@@ -5,10 +5,10 @@ export declare type AuthMapper = {
     state: (state: AuthState) => any;
     actions: (actions: AuthActions) => any;
 };
-export declare type AuthStateMapper<S extends object> = (state: AuthState) => S;
-export declare type AuthActionsMapper<A> = (state: AuthActions) => A;
-export declare type StateHookFunction<T> = (() => T) & (<S extends object>(mapper: (state: T) => S) => S);
-export declare const useAuth: <S extends object>(stateMapper?: AuthStateMapper<S>) => S;
+export declare type StateHookFunction<T> = (() => T) & (<S extends {}>(mapper: (state: T) => S) => S);
+export declare type AuthStateMapper<S> = (state: AuthState) => S;
+export declare function useAuth(): AuthState;
+export declare function useAuth<S>(stateMapper: AuthStateMapper<S>): S;
 /**
  * ```jsx
  * export const MyFunctionComponent = () => {

package/auth/hooks.js

@@ -10,9 +10,9 @@ const defaultMapper = {
   state: state => state,
   actions: actions => actions
 };
-export const useAuth = (stateMapper = defaultMapper.state) => {
+export function useAuth(stateMapper = defaultMapper.state) {
   return useSelector(state => stateMapper(state[authStoreName]), shallowEqual);
-};
+}
 /**
  * ```jsx
  * export const MyFunctionComponent = () => {

package/auth/login.d.ts

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

package/auth/login.js

@@ -1,4 +1,9 @@
 import { loginReducers, loginActions } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useLoginState = stateMapper => stateHookGenerator(stateMapper, 'loginState');
+
+const defaultMapper = state => state;
+
+export function useLoginState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'loginState');
+}
 export const useLoginActions = () => reducerActionsGenerator(loginActions, loginReducers);

package/auth/mfa.d.ts

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

package/auth/mfa.js

@@ -1,4 +1,9 @@
 import { mfaActions, mfaReducers } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useMfaState = stateMapper => stateHookGenerator(stateMapper, 'mfaState');
+
+const defaultMapper = state => state;
+
+export function useMfaState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'mfaState');
+}
 export const useMfaActions = () => reducerActionsGenerator(mfaActions, mfaReducers);

package/auth/profile.d.ts

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

package/auth/profile.js

@@ -12,5 +12,10 @@ export const reloadProfileIfNeeded = () => {
     !loading && loadProfile();
   }, []);
 };
-export const useProfileState = stateMapper => stateHookGenerator(stateMapper, 'profileState');
+
+const defaultMapper = state => state;
+
+export function useProfileState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'profileState');
+}
 export const useProfileActions = () => reducerActionsGenerator(profileActions, profileReducers);

package/auth/resetPhoneNumber.d.ts

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

package/auth/resetPhoneNumber.js

@@ -1,4 +1,9 @@
 import { resetPhoneNumberReducers, resetPhoneNumberActions } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useResetPhoneNumberState = stateMapper => stateHookGenerator(stateMapper, 'resetPhoneNumberState');
+
+const defaultMapper = state => state;
+
+export function useResetPhoneNumberState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'resetPhoneNumberState');
+}
 export const useResetPhoneNumberActions = () => reducerActionsGenerator(resetPhoneNumberActions, resetPhoneNumberReducers);

package/auth/roles.d.ts

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

package/auth/roles.js

@@ -1,4 +1,9 @@
 import { rolesReducers, rolesActions } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useRolesState = stateMapper => stateHookGenerator(stateMapper, 'rolesState');
+
+const defaultMapper = state => state;
+
+export function useRolesState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'rolesState');
+}
 export const useRolesActions = () => reducerActionsGenerator(rolesActions, rolesReducers);

package/auth/securityPolicy.d.ts

@@ -1,7 +1,7 @@
 import { SecurityPolicyActions, SecurityPolicyState } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type SecurityPolicyStateMapper<S extends object> = (state: SecurityPolicyState) => S;
-export declare const useSecurityPolicyState: StateHookFunction<SecurityPolicyState>;
+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;

package/auth/securityPolicy.js

@@ -1,7 +1,12 @@
 import { securityPolicyActions, securityPolicyReducers } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
 import { useEffect } from 'react';
-export const useSecurityPolicyState = stateMapper => stateHookGenerator(stateMapper, 'securityPolicyState');
+
+const defaultMapper = state => state;
+
+export function useSecurityPolicyState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'securityPolicyState');
+}
 export const useSecurityPolicyActions = () => reducerActionsGenerator(securityPolicyActions, securityPolicyReducers);
 export const usePublicPolicySettings = (loadOnMount = false) => {
   const {

package/auth/sessions.d.ts

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

package/auth/sessions.js

@@ -1,4 +1,9 @@
 import { sessionsActions, sessionsReducers } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useSessionsState = stateMapper => stateHookGenerator(stateMapper, 'sessionsState');
+
+const defaultMapper = state => state;
+
+export function useSessionsState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'sessionsState');
+}
 export const useSessionsActions = () => reducerActionsGenerator(sessionsActions, sessionsReducers);

package/auth/sessionsPolicy.d.ts

@@ -1,6 +1,5 @@
-import { SessionsPolicyActions } from '@frontegg/redux-store';
-import { SessionsPolicyState } from '@frontegg/redux-store/auth/SessionsPolicyState/interfaces';
-import { StateHookFunction } from './hooks';
-export declare type SessionsPolicyStateMapper<S extends object> = (state: SessionsPolicyState) => S;
-export declare const useSessionsPolicyState: StateHookFunction<SessionsPolicyState>;
+import { SessionsPolicyState, SessionsPolicyActions } from '@frontegg/redux-store';
+export declare type SessionsPolicyStateMapper<S> = (state: SessionsPolicyState) => S;
+export declare function useSessionsPolicyState(): SessionsPolicyState;
+export declare function useSessionsPolicyState<S>(stateMapper: SessionsPolicyStateMapper<S>): S;
 export declare const useSessionsPolicyActions: () => SessionsPolicyActions;

package/auth/sessionsPolicy.js

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

package/auth/signup.d.ts

@@ -1,5 +1,5 @@
 import { SignUpState, SignUpActions } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type SignUpStateMapper<S extends object> = (state: SignUpState) => S;
-export declare const useSignUpState: StateHookFunction<SignUpState>;
+export declare type SignUpStateMapper<S> = (state: SignUpState) => S;
+export declare function useSignUpState(): SignUpState;
+export declare function useSignUpState<S>(stateMapper: SignUpStateMapper<S>): S;
 export declare const useSignUpActions: () => SignUpActions;

package/auth/signup.js

@@ -1,4 +1,9 @@
 import { signUpReducers, signUpActions } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useSignUpState = stateMapper => stateHookGenerator(stateMapper, 'signUpState');
+
+const defaultMapper = state => state;
+
+export function useSignUpState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'signUpState');
+}
 export const useSignUpActions = () => reducerActionsGenerator(signUpActions, signUpReducers);

package/auth/socialLogin.d.ts

@@ -1,5 +1,5 @@
 import { SocialLoginActions, SocialLoginState } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type SocialLoginStateMapper<S extends object> = (state: SocialLoginState) => S;
-export declare const useSocialLoginState: StateHookFunction<SocialLoginState>;
+export declare type SocialLoginStateMapper<S> = (state: SocialLoginState) => S;
+export declare function useSocialLoginState(): SocialLoginState;
+export declare function useSocialLoginState<S>(stateMapper: SocialLoginStateMapper<S>): S;
 export declare const useSocialLoginActions: () => SocialLoginActions;

package/auth/socialLogin.js

@@ -1,4 +1,9 @@
 import { socialLoginsActions, socialLoginsReducer } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useSocialLoginState = stateMapper => stateHookGenerator(stateMapper, 'socialLoginState');
+
+const defaultMapper = state => state;
+
+export function useSocialLoginState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'socialLoginState');
+}
 export const useSocialLoginActions = () => reducerActionsGenerator(socialLoginsActions, socialLoginsReducer);

package/auth/sso.d.ts

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

package/auth/sso.js

@@ -1,4 +1,9 @@
 import { ssoActions, ssoReducers } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useSSOState = stateMapper => stateHookGenerator(stateMapper, 'ssoState');
+
+const defaultMapper = state => state;
+
+export function useSSOState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'ssoState');
+}
 export const useSSOActions = () => reducerActionsGenerator(ssoActions, ssoReducers);

package/auth/team.d.ts

@@ -1,5 +1,5 @@
 import { TeamState, TeamActions } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type AuthTeamStateMapper<S extends object> = (state: TeamState) => S;
-export declare const useAuthTeamState: StateHookFunction<TeamState>;
+export declare type AuthTeamStateMapper<S> = (state: TeamState) => S;
+export declare function useAuthTeamState(): TeamState;
+export declare function useAuthTeamState<S>(stateMapper: AuthTeamStateMapper<S>): S;
 export declare const useAuthTeamActions: () => TeamActions;

package/auth/team.js

@@ -1,4 +1,9 @@
 import { teamActions, teamReducers } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useAuthTeamState = stateMapper => stateHookGenerator(stateMapper, 'teamState');
+
+const defaultMapper = state => state;
+
+export function useAuthTeamState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'teamState');
+}
 export const useAuthTeamActions = () => reducerActionsGenerator(teamActions, teamReducers);

package/auth/tenants.d.ts

@@ -1,5 +1,5 @@
 import { TenantsState, TenantsActions } from '@frontegg/redux-store';
-import { StateHookFunction } from './hooks';
-export declare type TenantsStateMapper<S extends object> = (state: TenantsState) => S;
-export declare const useTenantsState: StateHookFunction<TenantsState>;
+export declare type TenantsStateMapper<S> = (state: TenantsState) => S;
+export declare function useTenantsState(): TenantsState;
+export declare function useTenantsState<S>(stateMapper: TenantsStateMapper<S>): S;
 export declare const useTenantsActions: () => TenantsActions;

package/auth/tenants.js

@@ -1,4 +1,9 @@
 import { tenantsActions, tenantsReducers } from '@frontegg/redux-store';
 import { reducerActionsGenerator, stateHookGenerator } from './hooks';
-export const useTenantsState = stateMapper => stateHookGenerator(stateMapper, 'tenantsState');
+
+const defaultMapper = state => state;
+
+export function useTenantsState(stateMapper = defaultMapper) {
+  return stateHookGenerator(stateMapper, 'tenantsState');
+}
 export const useTenantsActions = () => reducerActionsGenerator(tenantsActions, tenantsReducers);

package/connectivity/hooks.d.ts

@@ -1,5 +1,6 @@
 import { ConnectivityActions, IConnectivityState } from '@frontegg/redux-store';
-export declare type AuthStateMapper<S extends object> = (state: IConnectivityState) => S;
+export declare type ConnectivityStateMapper<S> = (state: IConnectivityState) => S;
 export declare type StateHookFunction<T> = (() => T) & (<S extends object>(mapper: (state: T) => S) => S);
-export declare const useConnectivityState: <S extends object>(stateMapper?: AuthStateMapper<S> | undefined) => S;
+export declare function useConnectivityState(): IConnectivityState;
+export declare function useConnectivityState<S>(stateMapper: ConnectivityStateMapper<S>): S;
 export declare const useConnectivityActions: () => ConnectivityActions;

package/connectivity/hooks.js

@@ -2,13 +2,12 @@ import { useMemo } from 'react';
 import { shallowEqual } from 'react-redux';
 import { useSelector, useDispatch } from '../FronteggStoreContext';
 import { bindActionCreators, connectivityActions, connectivityStoreName } from '@frontegg/redux-store';
-export const useConnectivityState = stateMapper => {
-  return useSelector(state => {
-    var _stateMapper;
 
-    return (_stateMapper = stateMapper == null ? void 0 : stateMapper(state[connectivityStoreName])) != null ? _stateMapper : state[connectivityStoreName];
-  }, shallowEqual);
-};
+const defaultMapper = state => state;
+
+export function useConnectivityState(stateMapper = defaultMapper) {
+  return useSelector(state => stateMapper(state[connectivityStoreName]), shallowEqual);
+}
 export const useConnectivityActions = () => {
   const dispatch = useDispatch();
   return useMemo(() => bindActionCreators(connectivityActions, dispatch), [connectivityActions]);