@openfort/react 0.0.4 → 0.0.6

package/build/components/Common/TickList/index.d.ts

@@ -0,0 +1,7 @@
+declare const TickList: {
+    ({ items }: {
+        items: string[];
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default TickList;

package/build/components/Common/TickList/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const TickListContainer: import("styled-components").StyledComponent<"ul", any, {}, never>;
+export declare const TickItem: import("styled-components").StyledComponent<"li", any, {}, never>;
+export declare const TickIconWrapper: import("styled-components").StyledComponent<"span", any, {}, never>;

package/build/components/Openfort/OpenfortProvider.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 import { useConnectCallbackProps } from '../../hooks/useConnectCallback';
 import { ContextValue } from './context';
 import { ConnectUIOptions, OpenfortWalletConfig } from './types';
@@ -8,6 +9,8 @@ type OpenfortProviderProps = {
     publishableKey: string;
     uiConfig?: ConnectUIOptions;
     walletConfig?: OpenfortWalletConfig;
+    overrides?: SDKOverrides;
+    thirdPartyAuth?: ThirdPartyAuthConfiguration;
 } & useConnectCallbackProps;
 /**
  * OpenfortProvider component provides context and configuration for Openfort.
@@ -24,5 +27,5 @@ type OpenfortProviderProps = {
  * @param {OpenfortOptions} [openfortOptions] - Options for Openfort integration.
  * @throws Will throw an error if used outside of a WagmiProvider or if nested usages are detected.
  */
-export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, }: OpenfortProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
+export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, overrides, thirdPartyAuth, }: OpenfortProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
 export {};

package/build/components/Openfort/context.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { CustomTheme, Languages, Mode, Theme } from '../../types';
-import { OAuthProvider } from '@openfort/openfort-js';
+import { OAuthProvider, SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 import { ValueOf } from 'viem/_types/types/utils';
 import { useConnectCallbackProps } from '../../hooks/useConnectCallback';
 import { OpenfortUIOptionsExtended, OpenfortWalletConfig, routes } from './types';
@@ -31,8 +31,10 @@ export type ContextValue = {
     displayError: (message: string | React.ReactNode | null, code?: any) => void;
     resize: number;
     triggerResize: () => void;
-    uiConfig?: OpenfortUIOptionsExtended;
+    uiConfig: OpenfortUIOptionsExtended;
     walletConfig?: OpenfortWalletConfig;
+    overrides?: SDKOverrides;
+    thirdPartyAuth?: ThirdPartyAuthConfiguration;
 } & useConnectCallbackProps;
 export declare const Openfortcontext: React.Context<ContextValue | null>;
 export {};

package/build/components/Openfort/types.d.ts

@@ -1,6 +1,6 @@
 import React, { ReactNode } from 'react';
 import { CustomAvatarProps, CustomTheme, Languages, Mode, Theme } from '../../types';
-import { RecoveryMethod } from '@openfort/openfort-js';
+import { AccountTypeEnum, RecoveryMethod } from '@openfort/openfort-js';
 import { CoreOpenfortProviderProps } from '../../openfort/CoreOpenfortProvider';
 export declare const routes: {
     readonly PROVIDERS: "providers";
@@ -30,40 +30,24 @@ export declare enum AuthProvider {
     GUEST = "guest"
 }
 export declare const socialProviders: AuthProvider[];
+type PolicyConfig = string | Record<number, string>;
 type CommonWalletConfig = {
     /** Publishable key for the Shield API */
     shieldPublishableKey: string;
     /** Policy ID (pol_...) for the embedded signer */
-    ethereumProviderPolicyId?: string;
+    ethereumProviderPolicyId?: PolicyConfig;
+    accountType?: AccountTypeEnum;
     debug?: boolean;
 };
 type EncryptionSession = {
     /** Function to retrieve an encryption session using a session ID */
-    getEncryptionSession: () => Promise<string>;
+    getEncryptionSession?: () => Promise<string>;
     createEncryptedSessionEndpoint?: never;
 } | {
     /** API endpoint for creating an encrypted session */
     getEncryptionSession?: never;
-    createEncryptedSessionEndpoint: string;
+    createEncryptedSessionEndpoint?: string;
 };
-/**
- * Configuration for automatic recovery, which requires an encryption session.
- */
-type AutomaticRecoveryWalletConfig = {
-    /** Specifies that the recovery method is automatic */
-    recoveryMethod: RecoveryMethod.AUTOMATIC;
-} & EncryptionSession;
-type PasswordRecoveryWalletConfig = {
-    /** Specifies that the recovery method is password-based */
-    recoveryMethod: RecoveryMethod.PASSWORD;
-} & ((EncryptionSession & {
-    shieldEncryptionKey?: never;
-}) | {
-    /** Required shield encryption key when no encryption session is used */
-    shieldEncryptionKey: string;
-    createEncryptedSessionEndpoint?: never;
-    getEncryptionSession?: never;
-});
 /**
  * Configuration for automatic recovery.
  * - An encryption session is required.
@@ -76,16 +60,22 @@ type PasswordRecoveryWalletConfig = {
  * - `createEncryptedSessionEndpoint` as a string, OR
  * - `getEncryptionSession.` as a function that returns a promise.
  */
-export type OpenfortWalletConfig = CommonWalletConfig & (AutomaticRecoveryWalletConfig | PasswordRecoveryWalletConfig);
-export type OpenfortOptions = {
+export type OpenfortWalletConfig = CommonWalletConfig & EncryptionSession;
+export type OpenfortUIOptions = {
     linkWalletOnSignUp?: boolean;
-    authProviders?: AuthProvider[];
+    authProviders: AuthProvider[];
     skipEmailVerification?: boolean;
     termsOfServiceUrl?: string;
     privacyPolicyUrl?: string;
     logo?: React.ReactNode;
+};
+export type OpenfortSDKOptions = {
     overrides?: CoreOpenfortProviderProps['overrides'];
 };
+export type WalletRecoveryOptions = {
+    allowedMethods?: RecoveryMethod[];
+    defaultMethod?: RecoveryMethod;
+};
 export type ConnectUIOptions = {
     theme?: Theme;
     mode?: Mode;
@@ -106,7 +96,12 @@ export type ConnectUIOptions = {
     initialChainId?: number;
     enforceSupportedChains?: boolean;
     overlayBlur?: number;
-} & OpenfortOptions;
+    walletRecovery?: WalletRecoveryOptions;
+} & Partial<OpenfortUIOptions>;
+type WalletRecoveryOptionsExtended = {
+    allowedMethods: RecoveryMethod[];
+    defaultMethod: RecoveryMethod;
+};
 export type OpenfortUIOptionsExtended = {
     theme: Theme;
     mode: Mode;
@@ -132,5 +127,6 @@ export type OpenfortUIOptionsExtended = {
     walletOnboardingUrl?: string;
     disableSiweRedirect?: boolean;
     overlayBlur?: number;
-} & OpenfortOptions;
+    walletRecovery: WalletRecoveryOptionsExtended;
+} & OpenfortUIOptions;
 export {};

package/build/components/Pages/Recover/index.d.ts

@@ -1,3 +1,3 @@
 import React from "react";
-declare const CreateEmbeddedSigner: React.FC;
-export default CreateEmbeddedSigner;
+declare const RecoverPage: React.FC;
+export default RecoverPage;

package/build/components/Pages/Recover/styles.d.ts

@@ -0,0 +1 @@
+export declare const OtherMethodButton: import("styled-components").StyledComponent<"button", any, {}, never>;

package/build/components/PasswordStrength/PasswordStrengthIndicator.d.ts

@@ -0,0 +1,4 @@
+export declare const PasswordStrengthIndicator: ({ password, showPasswordIsTooWeakError }: {
+    password: string;
+    showPasswordIsTooWeakError: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/build/components/PasswordStrength/password-utility.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Password Utilities Module
+ * Provides functions for password strength calculation, passphrase generation,
+ * and password validation.
+ */
+export declare const MEDIUM_SCORE_THRESHOLD = 0.5;
+export declare const STRONG_SCORE_THRESHOLD = 0.75;
+export declare const VERY_STRONG_SCORE_THRESHOLD = 0.9;
+/** Password strength levels */
+export type PasswordStrengthLabel = 'Weak' | 'Medium' | 'Strong' | 'Very Strong';
+/** Password summary information */
+export interface PasswordSummary {
+    value: number;
+    label: PasswordStrengthLabel;
+}
+/**
+ * Gets a list of invalid characters in the provided text.
+ * Replaces spaces with 'SPACE' for visibility.
+ *
+ * @param text - The text to check for invalid characters
+ * @returns Array of unique invalid characters
+ */
+export declare function getInvalidCharacters(text?: string): string[];
+/**
+ * Converts a numeric password strength score to a human-readable label.
+ *
+ * @param score - The strength score (0-1)
+ * @returns The corresponding strength label
+ */
+export declare function getPasswordStrengthLabel(score: number): PasswordStrengthLabel;
+/**
+ * Calculates the diversity score of a password based on character types used.
+ * Considers lowercase, uppercase, digits, and special characters.
+ *
+ * @param password - The password to analyze
+ * @returns A score between 0 and 1 representing character diversity
+ */
+export declare function calculatePasswordDiversityScore(password: string): number;
+/**
+ * Calculates the overall password strength combining diversity and entropy.
+ *
+ * @param password - The password to analyze
+ * @returns A strength score between 0 and 1
+ */
+export declare function getPasswordStrength(password?: string): number;
+/**
+ * Gets a comprehensive summary of password strength.
+ *
+ * @param password - The password to analyze
+ * @returns An object containing the strength value and label
+ */
+export declare function getPasswordSummary(password?: string): PasswordSummary;

package/build/components/contexts/web3/index.d.ts

@@ -1,7 +1,6 @@
 /**
  * This provider is responsible for handling reusable web3 logic across the app.
  */
-import React from 'react';
 import { Address, Chain } from 'viem';
 type Web3Context = {
     connect: {
@@ -16,7 +15,7 @@ type Web3Context = {
         address: Address;
     };
 };
-declare const Web3Context: React.Context<Web3Context>;
+declare const Web3Context: import("react").Context<Web3Context>;
 export declare const Web3ContextProvider: ({ enabled, children, }: {
     enabled?: boolean;
     children: React.ReactNode;

package/build/hooks/openfort/auth/useAuthCallback.d.ts

@@ -1,6 +1,6 @@
 import { OpenfortHookOptions, OpenfortError } from "../../../types";
 import { AuthProvider } from "../../../components/Openfort/types";
-import { CreateWalletPostAuthOptions } from "./useCreateWalletPostAuth";
+import { CreateWalletPostAuthOptions } from "./useConnectToWalletPostAuth";
 import { EmailVerificationResult } from "./useEmailAuth";
 import { StoreCredentialsResult } from "./useOAuth";
 type CallbackResult = (StoreCredentialsResult & {

package/build/hooks/openfort/auth/{useCreateWalletPostAuth.d.ts → useConnectToWalletPostAuth.d.ts}

@@ -1,3 +1,4 @@
+import { UserWallet } from "../useWallets";
 export type CreateWalletPostAuthOptions = {
     /**
      * @default true
@@ -5,13 +6,13 @@ export type CreateWalletPostAuthOptions = {
      */
     logoutOnError?: boolean;
     /**
-     *
+     * @default true
+     * It will automatically try to recover the first wallet with automatic recovery.
      */
     automaticRecovery?: boolean;
 };
-export declare const useCreateWalletPostAuth: () => {
+export declare const useConnectToWalletPostAuth: () => {
     tryUseWallet: ({ logoutOnError: signOutOnError, automaticRecovery }: CreateWalletPostAuthOptions) => Promise<{
-        error?: import("../../..").OpenfortError;
-        wallet?: import("../useWallets").UserWallet;
+        wallet?: UserWallet;
     }>;
 };

package/build/hooks/openfort/auth/useEmailAuth.d.ts

@@ -1,6 +1,6 @@
 import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 import { OpenfortHookOptions, OpenfortError } from "../../../types";
-import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
+import { CreateWalletPostAuthOptions } from './useConnectToWalletPostAuth';
 import { UserWallet } from '../useWallets';
 export type EmailAuthResult = {
     error?: OpenfortError;

package/build/hooks/openfort/auth/useGuestAuth.d.ts

@@ -1,6 +1,6 @@
 import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 import { OpenfortHookOptions, OpenfortError } from "../../../types";
-import { CreateWalletPostAuthOptions } from "./useCreateWalletPostAuth";
+import { CreateWalletPostAuthOptions } from "./useConnectToWalletPostAuth";
 import { UserWallet } from "../useWallets";
 export type GuestHookResult = {
     error?: OpenfortError;

package/build/hooks/openfort/auth/useOAuth.d.ts

@@ -1,6 +1,6 @@
 import { OAuthProvider } from '@openfort/openfort-js';
 import { OpenfortHookOptions, OpenfortError } from '../../../types';
-import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
+import { CreateWalletPostAuthOptions } from './useConnectToWalletPostAuth';
 import { UserWallet } from "../useWallets";
 import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 export type InitializeOAuthOptions = {

package/build/hooks/openfort/auth/useSignOut.d.ts

@@ -1,6 +1,6 @@
-import { OpenfortHookOptions, OpenfortError } from '../../../types';
+import { OpenfortError, OpenfortHookOptions } from '../../../types';
 export declare function useSignOut(hookOptions?: OpenfortHookOptions): {
-    signOut: (options?: OpenfortHookOptions) => Promise<{} | undefined>;
+    signOut: (options?: OpenfortHookOptions) => Promise<{}>;
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;

package/build/hooks/openfort/useWallets.d.ts

@@ -1,10 +1,10 @@
-import { RecoveryMethod } from "@openfort/openfort-js";
+import { AccountTypeEnum, RecoveryMethod, RecoveryParams } from "@openfort/openfort-js";
 import { Hex } from "viem";
 import { Connector } from "wagmi";
 import { embeddedWalletId } from "../../constants/openfort";
 import { OpenfortError, OpenfortHookOptions } from "../../types";
 export type UserWallet = {
-    address?: Hex;
+    address: Hex;
     connectorType?: string;
     walletClientType?: string;
     connector?: Connector;
@@ -12,6 +12,7 @@ export type UserWallet = {
     isAvailable: boolean;
     isActive?: boolean;
     isConnecting?: boolean;
+    recoveryMethod?: RecoveryMethod;
 };
 type SetActiveWalletResult = {
     error?: OpenfortError;
@@ -31,11 +32,12 @@ type SetActiveWalletOptions = ({
 type CreateWalletResult = SetActiveWalletResult;
 type CreateWalletOptions = {
     password?: string;
+    accountType?: AccountTypeEnum;
 } & OpenfortHookOptions<CreateWalletResult>;
 type RecoverEmbeddedWalletResult = SetActiveWalletResult;
 type SetRecoveryOptions = {
-    recoveryMethod: RecoveryMethod;
-    recoveryPassword?: string;
+    previousRecovery: RecoveryParams;
+    newRecovery: RecoveryParams;
 } & OpenfortHookOptions<CreateWalletResult>;
 type WalletOptions = OpenfortHookOptions<SetActiveWalletResult | CreateWalletResult>;
 export declare function useWallets(hookOptions?: WalletOptions): {
@@ -45,15 +47,14 @@ export declare function useWallets(hookOptions?: WalletOptions): {
     isSuccess: boolean;
     isCreating: boolean;
     isConnecting: boolean;
+    hasWallet: boolean;
+    isLoadingWallets: boolean;
     wallets: UserWallet[];
     availableWallets: import("../../wallets/useWallets").WalletProps[];
     activeWallet: UserWallet | undefined;
     setRecovery: (params: SetRecoveryOptions) => Promise<RecoverEmbeddedWalletResult>;
-    createWallet: ({ password, ...options }?: CreateWalletOptions) => Promise<{
-        error: OpenfortError;
-    } | {
-        wallet: UserWallet;
-    }>;
+    reset: () => void;
+    createWallet: ({ password, ...options }?: CreateWalletOptions) => Promise<CreateWalletResult>;
     setActiveWallet: (options: SetActiveWalletOptions | string) => Promise<SetActiveWalletResult>;
 };
 export {};

package/build/index.d.ts

@@ -4,7 +4,6 @@ export { default as getDefaultConfig } from './defaultConfig';
 export { default as getDefaultConnectors } from './defaultConnectors';
 export { wallets } from './wallets';
 export { AuthProvider, } from './components/Openfort/types';
-export { Openfortcontext, } from './components/Openfort/context';
 export { OpenfortProvider, } from './components/Openfort/OpenfortProvider';
 export { OpenfortButton } from './components/ConnectButton';
 export { default as Avatar } from './components/Common/Avatar';