@frontegg/react-hooks 7.77.0 → 7.78.0-alpha.1

package/audits/auditLogs.d.ts

@@ -1,3 +1,2 @@
-import { AuditLogsState, AuditsActions } from '@frontegg/redux-store';
-export declare function useAuditLogsState(): AuditLogsState;
-export declare const useAuditLogsActions: () => AuditsActions;
+import type { AuditLogsState, AuditsActions } from '@frontegg/redux-store';
+export declare const useAuditLogsState: <S = AuditLogsState>(selector?: (s: AuditLogsState) => S) => S, useAuditLogsActions: () => AuditsActions;

package/audits/auditLogs.js

@@ -1,9 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useAuditLogsState() {
-  const state = useStore().store.auditLogs.auditLogsState;
-  return useSnapshot(state);
-}
-export const useAuditLogsActions = () => {
-  return useStore().stateActions.auditLogs;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useAuditLogsState,
+  useSliceActions: useAuditLogsActions
+} = createSliceHooks({
+  getState: s => s.auditLogs.auditLogsState,
+  getActions: a => a.auditLogs
+});

package/audits/auditsMetadata.d.ts

@@ -1,3 +1,2 @@
-import { AuditsActions, AuditsMetadataState } from '@frontegg/redux-store';
-export declare function useAuditsMetadataState(): AuditsMetadataState;
-export declare const useAuditsMetadataActions: () => AuditsActions;
+import type { AuditsMetadataState, AuditsActions } from '@frontegg/redux-store';
+export declare const useAuditsMetadataState: <S = AuditsMetadataState>(selector?: (s: AuditsMetadataState) => S) => S, useAuditsMetadataActions: () => AuditsActions;

package/audits/auditsMetadata.js

@@ -1,9 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useAuditsMetadataState() {
-  const state = useStore().store.auditLogs.auditsMetadataState;
-  return useSnapshot(state);
-}
-export const useAuditsMetadataActions = () => {
-  return useStore().stateActions.auditLogs;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useAuditsMetadataState,
+  useSliceActions: useAuditsMetadataActions
+} = createSliceHooks({
+  getState: s => s.auditLogs.auditsMetadataState,
+  getActions: a => a.auditLogs
+});

package/audits/hooks.d.ts

@@ -1,9 +1,2 @@
-import { AuditsActions, AuditsState } from '@frontegg/redux-store';
-export type AuditsMapper = {
-    state: (state: AuditsState) => any;
-    actions: (actions: AuditsActions) => any;
-};
-export 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;
+import type { AuditsState, AuditsActions } from '@frontegg/redux-store';
+export declare const useAuditsState: <S = AuditsState>(selector?: (s: AuditsState) => S) => S, useAuditsActions: () => AuditsActions;

package/audits/hooks.js

@@ -1,14 +1,10 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-const defaultMapper = {
-  state: state => state,
-  actions: actions => actions
-};
-export function useAuditsState(stateMapper = defaultMapper.state) {
-  const state = useStore().store.auditLogs;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return stateMapper(useSnapshot(state));
-}
-export const useAuditsActions = () => {
-  return useStore().stateActions.auditLogs;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useAuditsState,
+  // supports optional selector
+  useSliceActions: useAuditsActions
+} = createSliceHooks({
+  getState: s => s.auditLogs,
+  // whole audits slice
+  getActions: a => a.auditLogs
+});

package/auth/acceptInvitation.d.ts

@@ -1,5 +1,7 @@
-import { AcceptInvitationState, AcceptInvitationActions } from '@frontegg/redux-store';
-export 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;
+import type { AcceptInvitationState } from '@frontegg/redux-store';
+export declare const useAcceptInvitationState: <S = AcceptInvitationState>(selector?: (s: AcceptInvitationState) => S) => S, useAcceptInvitationActions: () => {
+    setAcceptInvitationState: (state: Partial<AcceptInvitationState>) => void;
+    resetAcceptInvitationState: () => void;
+    acceptInvitation: (payload: import("dist/@frontegg/rest-api").IAcceptInvitation) => Promise<void>;
+    acceptInvitationWithOTC: (payload: import("dist/@frontegg/rest-api").IAcceptInvitationWithOTC) => Promise<void>;
+};

package/auth/acceptInvitation.js

@@ -1,13 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-
-// TODO: remove useless stateMapper, valtio already does this
-
-const defaultMapper = state => state;
-export function useAcceptInvitationState(stateMapper = defaultMapper) {
-  const state = useStore().store.auth.acceptInvitationState;
-  return stateMapper(useSnapshot(state));
-}
-export const useAcceptInvitationActions = () => {
-  return useStore().stateActions.auth.acceptInvitationActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useAcceptInvitationState,
+  useSliceActions: useAcceptInvitationActions
+} = createSliceHooks({
+  getState: s => s.auth.acceptInvitationState,
+  getActions: a => a.auth.acceptInvitationActions
+});

package/auth/activateAccount.d.ts

@@ -1,5 +1,11 @@
-import { ActivateAccountState, ActivateAccountActions } from '@frontegg/redux-store';
-export 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;
+import type { ActivateAccountState } from '@frontegg/redux-store';
+export declare const useActivateAccountState: <S = ActivateAccountState>(selector?: (s: ActivateAccountState) => S) => S, useActivateAccountActions: () => {
+    setActivateState: (state: Partial<ActivateAccountState>) => void;
+    resetActivateState: () => void;
+    setActivateStrategyState: (state: Partial<ActivateAccountState["activationStrategy"]>) => void;
+    activateAccount: (_payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IActivateAccountPayload>) => Promise<void>;
+    preActivateAccount: (payload: import("@frontegg/redux-store").IPreActivateAccount) => Promise<void>;
+    getActivateAccountStrategy: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IGetActivateAccountStrategy, import("dist/@frontegg/rest-api").IGetActivateAccountStrategyResponse>) => Promise<void>;
+    resendActivationEmail: (payload: import("@frontegg/redux-store").WithCallback<import("dist/@frontegg/rest-api").IResendActivationEmail>) => Promise<void>;
+    activateAccountWithCode: (_payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").IActivateAccountWithOTCPayload>) => Promise<void>;
+};

package/auth/activateAccount.js

@@ -1,13 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-
-// TODO: remove useless stateMapper, valtio already does this
-
-const defaultMapper = state => state;
-export function useActivateAccountState(stateMapper = defaultMapper) {
-  const state = useStore().store.auth.activateAccountState;
-  return stateMapper(useSnapshot(state));
-}
-export const useActivateAccountActions = () => {
-  return useStore().stateActions.auth.activateAccountActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useActivateAccountState,
+  useSliceActions: useActivateAccountActions
+} = createSliceHooks({
+  getState: s => s.auth.activateAccountState,
+  getActions: a => a.auth.activateAccountActions
+});

package/auth/allAccounts.d.ts

@@ -1,7 +1,47 @@
-import { IAllAccountsState, AllAccountsActions, IAllAccountsDialogsState, AllAccountsDialogActions } from '@frontegg/redux-store';
-export type AllAccountsStateMapper<S> = (state: IAllAccountsState) => S;
-export declare function useAllAccountsState(): IAllAccountsState;
-export declare function useAllAccountsState<S>(stateMapper: AllAccountsStateMapper<S>): S;
-export declare const useAllAccountsActions: () => AllAccountsActions;
-export declare function useAllAccountsDialogsState(): IAllAccountsDialogsState;
-export declare const useAllAccountsDialogsActions: () => AllAccountsDialogActions;
+import { IAllAccountsState, IAllAccountsDialogsState } from '@frontegg/redux-store';
+export declare const useAllAccountsState: <S = IAllAccountsState>(selector?: (s: IAllAccountsState) => S) => S, useAllAccountsActions: () => {
+    setAllAccountsLoader: (payload: import("@frontegg/redux-store").AllAccountsStateIndicator) => void;
+    setAllAccountsError: (payload: import("@frontegg/redux-store").AllAccountsStateIndicator) => void;
+    setAllAccountsState: (state: Partial<IAllAccountsState>) => void;
+    setSelectedAccountState: (payload: Partial<IAllAccountsState["selectedAccount"]>) => void;
+    resetAllAccountsState: () => void;
+    clearSelectedAccount: () => void;
+    loadAccounts: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["loadAccounts"]) => Promise<void>;
+    searchAccounts: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["searchAccounts"]) => Promise<void>;
+    updateSubAccountAccessForUser: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["updateSubAccountAccessForUser"]) => Promise<void>;
+    createSubAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["createSubAccount"]) => Promise<void>;
+    updateSubAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["updateSubAccount"]) => Promise<void>;
+    deleteSubAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["deleteSubAccount"]) => Promise<void>;
+    updateSubAccountSettings: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["updateSubAccountSettings"]) => Promise<void>;
+    updateSubAccountManagement: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["updateSubAccountManagement"]) => Promise<void>;
+    updateSubAccountHierarchySettings: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["updateSubAccountHierarchySettings"]) => Promise<void>;
+    addUsersToAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["addUsersToAccount"]) => Promise<void>;
+    getAccountUsers: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["getAccountUsers"]) => Promise<void>;
+    deleteUsersFromAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["deleteUsersFromAccount"]) => Promise<void>;
+    setUserRolesForSubAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["setUserRolesForSubAccount"]) => Promise<void>;
+    getUserJwtForSubAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["getUserJwtForSubAccount"]) => Promise<void>;
+    setRootAccountData: () => Promise<void>;
+    setSelectedSubAccountData: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["setSelectedSubAccountData"]) => Promise<void>;
+    loadNumberOfUsersForSelectedSubAccount: (payload: import("@frontegg/redux-store").IAllAccountsStateActionsPayloads["loadNumberOfUsersForSelectedSubAccount"]) => Promise<void>;
+}, useAllAccountsDialogsState: () => IAllAccountsDialogsState, useAllAccountsDialogsActions: () => {
+    setAllAccountDialogsState: (payload: Partial<IAllAccountsDialogsState>) => void;
+    resetAllAccountDialogsState: () => void;
+    openCreateSubAccountDialog: (payload: Partial<import("@frontegg/redux-store").TCreateSubAccountDialogState>) => void;
+    closeCreateSubAccountDialog: () => void;
+    openUpdateSubAccountDialog: (payload: Partial<import("@frontegg/redux-store").TUpdateAccountDialogState>) => void;
+    closeUpdateSubAccountDialog: () => void;
+    openEnableSubAccountManagementDialog: (payload: Partial<import("@frontegg/redux-store").TUpdateSubAccountManagementState>) => void;
+    closeEnableSubAccountManagementDialog: () => void;
+    openUpdateSubAccountHierarchySettingsDialog: (payload: Partial<import("@frontegg/redux-store").TUpdateSubAccountHierarchySettingsDialogState>) => void;
+    closeUpdateSubAccountHierarchySettingsDialog: () => void;
+    openDisableSubAccountManagementDialog: (payload: Partial<import("@frontegg/redux-store").TUpdateSubAccountManagementState>) => void;
+    closeDisableSubAccountManagementDialog: () => void;
+    openDeleteSubAccountDialog: (payload: Partial<import("@frontegg/redux-store").TDeleteSubAccountDialogState>) => void;
+    closeDeleteSubAccountDialog: () => void;
+    openAddUsersToAccountDialog: (payload: Partial<import("@frontegg/redux-store").TAddUsersToSubAccountDialogState>) => void;
+    closeAddUsersToAccountDialog: () => void;
+    openDeleteUserFromAccountDialog: (payload: Partial<import("@frontegg/redux-store").TDeleteUserFromSubAccountDialogState>) => void;
+    closeDeleteUserFromAccountDialog: () => void;
+    openEditUserRolesDialog: (payload: Partial<import("@frontegg/redux-store").TEditUserRolesDialogState>) => void;
+    closeEditUserRolesDialog: () => void;
+};

package/auth/allAccounts.js

@@ -1,20 +1,12 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-
-// TODO: remove useless stateMapper, valtio already does this
-
-const defaultMapper = state => state;
-export function useAllAccountsState(stateMapper = defaultMapper) {
-  const state = useStore().store.auth.allAccountsState;
-  return stateMapper(useSnapshot(state));
-}
-export const useAllAccountsActions = () => {
-  return useStore().stateActions.auth.allAccountsActions;
-};
-export function useAllAccountsDialogsState() {
-  const state = useStore().store.auth.allAccountsDialogsState;
-  return useSnapshot(state);
-}
-export const useAllAccountsDialogsActions = () => {
-  return useStore().stateActions.auth.allAccountsDialogActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useAllAccountsState,
+  useSliceActions: useAllAccountsActions,
+  useSliceDialogsState: useAllAccountsDialogsState,
+  useSliceDialogsActions: useAllAccountsDialogsActions
+} = createSliceHooks({
+  getState: s => s.auth.allAccountsState,
+  getActions: a => a.auth.allAccountsActions,
+  getDialogsState: s => s.auth.allAccountsDialogsState,
+  getDialogsActions: a => a.auth.allAccountsDialogActions
+});

package/auth/apiTokens.d.ts

@@ -1,3 +1,14 @@
-import { ApiTokensActions, ApiTokensState } from '@frontegg/redux-store';
-export declare function useApiTokensState(): ApiTokensState;
-export declare const useApiTokensActions: () => ApiTokensActions;
+import type { ApiTokensState } from '@frontegg/redux-store';
+export declare const useApiTokensState: <S = ApiTokensState>(selector?: (s: ApiTokensState) => S) => S, useApiTokensActions: () => {
+    setApiTokensLoader: (payload: import("@frontegg/redux-store").ApiStateIndicator) => void;
+    setApiTokensError: (payload: import("@frontegg/redux-store").ApiStateIndicator) => void;
+    setApiTokensState: (state: Partial<ApiTokensState>) => void;
+    resetApiTokensState: () => void;
+    loadApiTokens: (payload?: import("@frontegg/redux-store").WithSilentLoad<import("@frontegg/redux-store").WithCallback>) => Promise<void>;
+    loadUserApiTokens: (payload?: import("@frontegg/redux-store").WithRetryConfig<import("@frontegg/redux-store").WithSilentLoad<import("@frontegg/redux-store").WithCallback>>) => Promise<void>;
+    loadTenantApiTokens: (payload?: import("@frontegg/redux-store").WithRetryConfig<import("@frontegg/redux-store").WithSilentLoad<import("@frontegg/redux-store").WithCallback>>) => Promise<void>;
+    addTenantApiToken: (payload: import("@frontegg/redux-store").AddTenantApiTokenPayload) => Promise<void>;
+    addUserApiToken: (payload: import("@frontegg/redux-store").AddUserApiTokenPayload) => Promise<void>;
+    deleteUserApiToken: (payload: string) => Promise<void>;
+    deleteTenantApiToken: (payload: string) => Promise<void>;
+};

package/auth/apiTokens.js

@@ -1,9 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useApiTokensState() {
-  const state = useStore().store.auth.apiTokensState;
-  return useSnapshot(state);
-}
-export const useApiTokensActions = () => {
-  return useStore().stateActions.auth.apiTokensActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useApiTokensState,
+  useSliceActions: useApiTokensActions
+} = createSliceHooks({
+  getState: s => s.auth.apiTokensState,
+  getActions: a => a.auth.apiTokensActions
+});

package/auth/applications.d.ts

@@ -1,3 +1,22 @@
-import { ApplicationsActions, ApplicationsState } from '@frontegg/redux-store';
-export declare function useApplicationsState(): ApplicationsState;
-export declare const useApplicationsActions: () => ApplicationsActions;
+import type { ApplicationsState } from '@frontegg/redux-store';
+export declare const useApplicationsState: <S = ApplicationsState>(selector?: (s: ApplicationsState) => S) => S, useApplicationsActions: () => {
+    setApplicationsState: (payload: Partial<ApplicationsState>) => void;
+    resetApplicationsState: () => void;
+    loadUserApplications: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadAccountApplications: (payload?: import("@frontegg/redux-store").WithRetryConfig<{}>) => Promise<void>;
+    loadMultipleUsersApplications: ({ userIds, retryConfig }: import("@frontegg/redux-store").WithRetryConfig<{
+        userIds: string[];
+    }>) => Promise<Record<string, import("dist/@frontegg/rest-api").IApplicationsResponse[]> | undefined>;
+    assignUserToApps: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").UserAppsAssignmentPayload>) => Promise<void>;
+    unassignUserFromApps: (payload: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").UserAppsAssignmentPayload>) => Promise<void>;
+    assignNewUserToApps: ({ appIds, user }: {
+        appIds?: string[];
+        user: import("dist/@frontegg/rest-api").ITeamUser;
+    }) => Promise<((import("dist/@frontegg/rest-api").IApplicationsResponse & {
+        userIds?: string[];
+    }) | never[])[] | undefined>;
+    mapUsersWithApplicationData: ({ shouldLoadApps, users, retryConfig, }: import("@frontegg/redux-store").WithRetryConfig<{
+        shouldLoadApps?: boolean;
+        users: import("dist/@frontegg/rest-api").ITeamUser[];
+    }>) => Promise<import("dist/@frontegg/rest-api").ITeamUser[]>;
+};

package/auth/applications.js

@@ -1,9 +1,8 @@
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useApplicationsState() {
-  const state = useStore().store.auth.applicationsState;
-  return useSnapshot(state);
-}
-export const useApplicationsActions = () => {
-  return useStore().stateActions.auth.applicationsActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useApplicationsState,
+  useSliceActions: useApplicationsActions
+} = createSliceHooks({
+  getState: s => s.auth.applicationsState,
+  getActions: a => a.auth.applicationsActions
+});

package/auth/customLogin.d.ts

@@ -1,6 +1,12 @@
-import { CustomLoginState, CustomLoginActions } from '@frontegg/redux-store';
-export declare function useCustomLoginState(): CustomLoginState;
-export declare const useCustomLoginActions: () => CustomLoginActions;
+import type { CustomLoginState } from '@frontegg/redux-store';
+export declare const useCustomLoginState: <S = CustomLoginState>(selector?: (s: CustomLoginState) => S) => S, useCustomLoginActions: () => {
+    setCustomLoginState: (payload: Partial<CustomLoginState>) => void;
+    resetCustomLoginState: () => void;
+    loadTenantMetadata: () => Promise<void>;
+    updateTenantMetadata: (payload: import("@frontegg/redux-store").WithCallback<Partial<import("@frontegg/redux-store").UpdateTenantMetadataRequest>>) => Promise<void>;
+    customLoginEnabled: () => Promise<boolean>;
+    loadCustomLoginRoutes: (payload?: import("@frontegg/redux-store").WithCallback<import("@frontegg/redux-store").WithRetryConfig<{}>>) => Promise<void>;
+};
 export declare const useCustomLoginTheme: () => {
     customLoginTheme: any;
     getCustomLoginThemeValue: (path?: string) => any;

package/auth/customLogin.js

@@ -1,20 +1,17 @@
 import { useCallback } from 'react';
 import getValue from 'get-value';
-import { useStore } from '../FronteggStoreContext';
-import { useSnapshot } from '../useSnapshot';
-export function useCustomLoginState() {
-  const state = useStore().store.auth.customLoginState;
-  return useSnapshot(state);
-}
-export const useCustomLoginActions = () => {
-  return useStore().stateActions.auth.customLoginActions;
-};
+import { createSliceHooks } from '../useSnapshot/hookFactory';
+export const {
+  useSliceState: useCustomLoginState,
+  useSliceActions: useCustomLoginActions
+} = createSliceHooks({
+  getState: s => s.auth.customLoginState,
+  getActions: a => a.auth.customLoginActions
+});
 export const useCustomLoginTheme = () => {
   var _useCustomLoginState$, _useCustomLoginState$2, _useCustomLoginState$3;
   const customLoginTheme = (_useCustomLoginState$ = useCustomLoginState().tenantMetadata) == null ? void 0 : (_useCustomLoginState$2 = _useCustomLoginState$.configuration) == null ? void 0 : (_useCustomLoginState$3 = _useCustomLoginState$2.themeV2) == null ? void 0 : _useCustomLoginState$3.loginBox;
-  const getCustomLoginThemeValue = useCallback(path => {
-    return path && customLoginTheme ? getValue(customLoginTheme, path) : customLoginTheme;
-  }, [customLoginTheme]);
+  const getCustomLoginThemeValue = useCallback(path => path && customLoginTheme ? getValue(customLoginTheme, path) : customLoginTheme, [customLoginTheme]);
   return {
     customLoginTheme,
     getCustomLoginThemeValue

package/auth/entitlements.d.ts

@@ -1,35 +1,16 @@
-import { CustomAttributes } from '@frontegg/entitlements-javascript-commons';
+import type { CustomAttributes } from '@frontegg/entitlements-javascript-commons';
 import { EntitledToOptions, Entitlement } from '@frontegg/redux-store';
-/**
- @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?: CustomAttributes) => 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?: CustomAttributes) => Entitlement;
-/**
- @param options
- @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?: CustomAttributes) => Entitlement;
-/**
- @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 useFeatureEntitlements: (key: string, custom?: CustomAttributes) => Entitlement;
+export declare const usePermissionEntitlements: (key: string, custom?: CustomAttributes) => Entitlement;
+export declare const useEntitlements: (opts: EntitledToOptions, custom?: CustomAttributes) => Entitlement;
 export declare const useEntitlementsActions: () => {
-    isEntitledTo: (options: EntitledToOptions, customAttributes?: CustomAttributes) => Entitlement;
+    isEntitledTo: (options: EntitledToOptions, custom?: CustomAttributes) => Entitlement;
 };
 /**
  @returns if the option to use entitlements is enabled
  */
 export declare const useEntitlementsOptions: () => {
     isEntitlementsEnabled: boolean;
-    isEntitledTo: (options: EntitledToOptions, customAttributes?: CustomAttributes) => Entitlement;
+    isEntitledTo: (o: EntitledToOptions, c?: CustomAttributes) => Entitlement;
     verifyIsEntitledFF: boolean;
 };

package/auth/entitlements.js

@@ -1,112 +1,80 @@
-import { useAuthUserOrNull } from './hooks';
 import { useMemo } from 'react';
+import { getEntitlements, getFeatureEntitlements, getPermissionEntitlements } from '@frontegg/redux-store';
+import { useAuthUserOrNull } from './hooks';
 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 entitlements state as stored in the user
- */
+/** Current entitlements object (or empty) */
 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 : {};
+  return (_useSnapshot$user$ent = (_useSnapshot$user = useSnapshot(useStore().store.auth).user) == null ? void 0 : _useSnapshot$user.entitlements) != null ? _useSnapshot$user$ent : {};
 };
 
-/**
- * @returns user state
- */
-const useUserState = () => {
-  return useAuthUserOrNull() || undefined;
-};
+/** Currently logged-in user claims (or undefined) */
+const useUserState = () => useAuthUserOrNull() || undefined;
 
-/**
- * @param customAttributes user attributes
- * @returns is entitled query data including entitlement state and final attributes (consumer and frontegg)
- */
-const useEntitlementsQueryData = customAttributes => {
+/** Shared attributes object passed to the entitlement engine */
+const useAttributes = custom => {
   const user = useUserState();
-  const entitlements = useEntitlementsState();
-  const attributes = {
-    custom: customAttributes,
+  return useMemo(() => ({
+    custom,
     jwt: user
-  };
-  return {
-    entitlements,
-    attributes
-  };
+  }), [custom, user]);
 };
 
-/**
- @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
-  } = useEntitlementsQueryData(customAttributes);
+/** Single resolver so we don’t repeat switch-cases in every hook */
+const resolveEntitlement = (variant, keyOrOpts, entitlements, attrs, appName) => {
+  switch (variant) {
+    case 'feature':
+      return getFeatureEntitlements(entitlements, keyOrOpts, attrs, undefined, appName);
+    case 'permission':
+      return getPermissionEntitlements(entitlements, keyOrOpts, attrs, undefined, appName);
+    default:
+      return getEntitlements(entitlements, keyOrOpts, attrs, undefined, appName);
+  }
+};
+export const useFeatureEntitlements = (key, custom) => {
+  const entitlements = useEntitlementsState();
+  const attrs = useAttributes(custom);
   const {
     appName
   } = useRootState();
-  return getFeatureEntitlements(entitlements, key, attributes, undefined, appName);
+  return resolveEntitlement('feature', key, entitlements, attrs, appName);
 };
-
-/**
- @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
-  } = useEntitlementsQueryData(customAttributes);
+export const usePermissionEntitlements = (key, custom) => {
+  const entitlements = useEntitlementsState();
+  const attrs = useAttributes(custom);
   const {
     appName
   } = useRootState();
-  return getPermissionEntitlements(entitlements, key, attributes, undefined, appName);
+  return resolveEntitlement('permission', key, entitlements, attrs, appName);
 };
-
-/**
- @param options
- @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
-  } = useEntitlementsQueryData(customAttributes);
+export const useEntitlements = (opts, custom) => {
+  const entitlements = useEntitlementsState();
+  const attrs = useAttributes(custom);
   const {
     appName
   } = useRootState();
-  return getEntitlements(entitlements, options, attributes, undefined, appName);
+  return resolveEntitlement('any', opts, entitlements, attrs, appName);
 };
-
-/**
- @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();
   const {
     appName
   } = useRootState();
+  const user = useUserState(); // stable referentially via useAuthUserOrNull
+  // Pre-compute attrs once so callers don’t need to worry
   return useMemo(() => ({
-    isEntitledTo: (options, customAttributes) => {
-      const attributes = {
-        custom: customAttributes,
+    isEntitledTo: (options, custom) => {
+      const attrs = {
+        custom,
         jwt: user
       };
-      return getEntitlements(entitlements, options, attributes, undefined, appName);
+      return getEntitlements(entitlements, options, attrs, undefined, appName);
     }
-  }), [user, entitlements]);
+  }), [entitlements, user, appName]);
 };
 
 /**

package/auth/forgotPassword.d.ts

@@ -1,3 +1,12 @@
-import { ForgotPasswordState, ForgotPasswordActions } from '@frontegg/redux-store';
-export declare function useForgotPasswordState(): ForgotPasswordState;
-export declare const useForgotPasswordActions: () => ForgotPasswordActions;
+import type { ForgotPasswordState } from '@frontegg/redux-store';
+export declare const useForgotPasswordState: <S = ForgotPasswordState>(selector?: (s: ForgotPasswordState) => S) => S, useForgotPasswordActions: () => {
+    setForgotPasswordState: (payload: Partial<ForgotPasswordState>) => void;
+    resetForgotPasswordState: () => void;
+    forgotPassword: (payload: import("@frontegg/redux-store").IForgotPasswordPayload) => Promise<void>;
+    resetPassword: (payload: import("@frontegg/redux-store").IResetPasswordPayload) => Promise<void>;
+    loadPasswordConfig: (payload?: import("dist/@frontegg/rest-api").IGetUserPasswordConfig) => Promise<void>;
+    determinePasswordRecoveryStrategy: (payload: import("@frontegg/redux-store").IDeterminePasswordRecoveryStrategyPayload) => Promise<void>;
+    sendPasswordRecoveryEmail: () => Promise<void>;
+    sendPasswordRecoverySms: () => Promise<void>;
+    verifyPasswordViaSms: (payload: import("@frontegg/redux-store").IVerifyPasswordViaSmsPayload) => Promise<void>;
+};