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

package/audits/auditLogs.d.ts

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

package/audits/auditLogs.js

@@ -1,8 +1,9 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useAuditLogsState,
-  useSliceActions: useAuditLogsActions
-} = createSliceHooks({
-  getState: s => s.auditLogs.auditLogsState,
-  getActions: a => a.auditLogs
-});
+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;
+};

package/audits/auditsMetadata.d.ts

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

package/audits/auditsMetadata.js

@@ -1,8 +1,9 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useAuditsMetadataState,
-  useSliceActions: useAuditsMetadataActions
-} = createSliceHooks({
-  getState: s => s.auditLogs.auditsMetadataState,
-  getActions: a => a.auditLogs
-});
+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;
+};

package/audits/hooks.d.ts

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

package/audits/hooks.js

@@ -1,10 +1,14 @@
-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
-});
+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;
+};

package/auth/acceptInvitation.d.ts

@@ -1,7 +1,5 @@
-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>;
-};
+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;

package/auth/acceptInvitation.js

@@ -1,8 +1,13 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useAcceptInvitationState,
-  useSliceActions: useAcceptInvitationActions
-} = createSliceHooks({
-  getState: s => s.auth.acceptInvitationState,
-  getActions: a => a.auth.acceptInvitationActions
-});
+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;
+};

package/auth/activateAccount.d.ts

@@ -1,11 +1,5 @@
-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>;
-};
+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;

package/auth/activateAccount.js

@@ -1,8 +1,13 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useActivateAccountState,
-  useSliceActions: useActivateAccountActions
-} = createSliceHooks({
-  getState: s => s.auth.activateAccountState,
-  getActions: a => a.auth.activateAccountActions
-});
+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;
+};

package/auth/allAccounts.d.ts

@@ -1,47 +1,7 @@
-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;
-};
+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;

package/auth/allAccounts.js

@@ -1,12 +1,20 @@
-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
-});
+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;
+};

package/auth/apiTokens.d.ts

@@ -1,14 +1,3 @@
-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>;
-};
+import { ApiTokensActions, ApiTokensState } from '@frontegg/redux-store';
+export declare function useApiTokensState(): ApiTokensState;
+export declare const useApiTokensActions: () => ApiTokensActions;

package/auth/apiTokens.js

@@ -1,8 +1,9 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useApiTokensState,
-  useSliceActions: useApiTokensActions
-} = createSliceHooks({
-  getState: s => s.auth.apiTokensState,
-  getActions: a => a.auth.apiTokensActions
-});
+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;
+};

package/auth/applications.d.ts

@@ -1,22 +1,3 @@
-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[]>;
-};
+import { ApplicationsActions, ApplicationsState } from '@frontegg/redux-store';
+export declare function useApplicationsState(): ApplicationsState;
+export declare const useApplicationsActions: () => ApplicationsActions;

package/auth/applications.js

@@ -1,8 +1,9 @@
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useApplicationsState,
-  useSliceActions: useApplicationsActions
-} = createSliceHooks({
-  getState: s => s.auth.applicationsState,
-  getActions: a => a.auth.applicationsActions
-});
+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;
+};

package/auth/customLogin.d.ts

@@ -1,12 +1,6 @@
-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>;
-};
+import { CustomLoginState, CustomLoginActions } from '@frontegg/redux-store';
+export declare function useCustomLoginState(): CustomLoginState;
+export declare const useCustomLoginActions: () => CustomLoginActions;
 export declare const useCustomLoginTheme: () => {
     customLoginTheme: any;
     getCustomLoginThemeValue: (path?: string) => any;

package/auth/customLogin.js

@@ -1,17 +1,20 @@
 import { useCallback } from 'react';
 import getValue from 'get-value';
-import { createSliceHooks } from '../useSnapshot/hookFactory';
-export const {
-  useSliceState: useCustomLoginState,
-  useSliceActions: useCustomLoginActions
-} = createSliceHooks({
-  getState: s => s.auth.customLoginState,
-  getActions: a => a.auth.customLoginActions
-});
+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;
+};
 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 => path && customLoginTheme ? getValue(customLoginTheme, path) : customLoginTheme, [customLoginTheme]);
+  const getCustomLoginThemeValue = useCallback(path => {
+    return path && customLoginTheme ? getValue(customLoginTheme, path) : customLoginTheme;
+  }, [customLoginTheme]);
   return {
     customLoginTheme,
     getCustomLoginThemeValue

package/auth/entitlements.d.ts

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

package/auth/entitlements.js

@@ -1,80 +1,112 @@
-import { useMemo } from 'react';
-import { getEntitlements, getFeatureEntitlements, getPermissionEntitlements } from '@frontegg/redux-store';
 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';
 
-/** Current entitlements object (or empty) */
+/**
+ * @returns entitlements state as stored in the user
+ */
 const useEntitlementsState = () => {
   var _useSnapshot$user$ent, _useSnapshot$user;
-  return (_useSnapshot$user$ent = (_useSnapshot$user = useSnapshot(useStore().store.auth).user) == null ? void 0 : _useSnapshot$user.entitlements) != null ? _useSnapshot$user$ent : {};
+  const state = useStore().store.auth;
+  return (_useSnapshot$user$ent = (_useSnapshot$user = useSnapshot(state).user) == null ? void 0 : _useSnapshot$user.entitlements) != null ? _useSnapshot$user$ent : {};
 };
 
-/** Currently logged-in user claims (or undefined) */
-const useUserState = () => useAuthUserOrNull() || undefined;
+/**
+ * @returns user state
+ */
+const useUserState = () => {
+  return useAuthUserOrNull() || undefined;
+};
 
-/** Shared attributes object passed to the entitlement engine */
-const useAttributes = custom => {
+/**
+ * @param customAttributes user attributes
+ * @returns is entitled query data including entitlement state and final attributes (consumer and frontegg)
+ */
+const useEntitlementsQueryData = customAttributes => {
   const user = useUserState();
-  return useMemo(() => ({
-    custom,
+  const entitlements = useEntitlementsState();
+  const attributes = {
+    custom: customAttributes,
     jwt: user
-  }), [custom, user]);
+  };
+  return {
+    entitlements,
+    attributes
+  };
 };
 
-/** 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);
+/**
+ @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);
   const {
     appName
   } = useRootState();
-  return resolveEntitlement('feature', key, entitlements, attrs, appName);
+  return getFeatureEntitlements(entitlements, key, attributes, undefined, appName);
 };
-export const usePermissionEntitlements = (key, custom) => {
-  const entitlements = useEntitlementsState();
-  const attrs = useAttributes(custom);
+
+/**
+ @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);
   const {
     appName
   } = useRootState();
-  return resolveEntitlement('permission', key, entitlements, attrs, appName);
+  return getPermissionEntitlements(entitlements, key, attributes, undefined, appName);
 };
-export const useEntitlements = (opts, custom) => {
-  const entitlements = useEntitlementsState();
-  const attrs = useAttributes(custom);
+
+/**
+ @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);
   const {
     appName
   } = useRootState();
-  return resolveEntitlement('any', opts, entitlements, attrs, appName);
+  return getEntitlements(entitlements, options, attributes, undefined, 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, custom) => {
-      const attrs = {
-        custom,
+    isEntitledTo: (options, customAttributes) => {
+      const attributes = {
+        custom: customAttributes,
         jwt: user
       };
-      return getEntitlements(entitlements, options, attrs, undefined, appName);
+      return getEntitlements(entitlements, options, attributes, undefined, appName);
     }
-  }), [entitlements, user, appName]);
+  }), [user, entitlements]);
 };
 
 /**

package/auth/forgotPassword.d.ts

@@ -1,12 +1,3 @@
-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>;
-};
+import { ForgotPasswordState, ForgotPasswordActions } from '@frontegg/redux-store';
+export declare function useForgotPasswordState(): ForgotPasswordState;
+export declare const useForgotPasswordActions: () => ForgotPasswordActions;