@openfort/react 0.0.5 → 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/context.d.ts

@@ -31,7 +31,7 @@ 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;

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

@@ -30,41 +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.
@@ -77,10 +60,10 @@ type PasswordRecoveryWalletConfig = {
  * - `createEncryptedSessionEndpoint` as a string, OR
  * - `getEncryptionSession.` as a function that returns a promise.
  */
-export type OpenfortWalletConfig = CommonWalletConfig & (AutomaticRecoveryWalletConfig | PasswordRecoveryWalletConfig);
+export type OpenfortWalletConfig = CommonWalletConfig & EncryptionSession;
 export type OpenfortUIOptions = {
     linkWalletOnSignUp?: boolean;
-    authProviders?: AuthProvider[];
+    authProviders: AuthProvider[];
     skipEmailVerification?: boolean;
     termsOfServiceUrl?: string;
     privacyPolicyUrl?: string;
@@ -89,6 +72,10 @@ export type OpenfortUIOptions = {
 export type OpenfortSDKOptions = {
     overrides?: CoreOpenfortProviderProps['overrides'];
 };
+export type WalletRecoveryOptions = {
+    allowedMethods?: RecoveryMethod[];
+    defaultMethod?: RecoveryMethod;
+};
 export type ConnectUIOptions = {
     theme?: Theme;
     mode?: Mode;
@@ -109,7 +96,12 @@ export type ConnectUIOptions = {
     initialChainId?: number;
     enforceSupportedChains?: boolean;
     overlayBlur?: number;
-} & OpenfortUIOptions;
+    walletRecovery?: WalletRecoveryOptions;
+} & Partial<OpenfortUIOptions>;
+type WalletRecoveryOptionsExtended = {
+    allowedMethods: RecoveryMethod[];
+    defaultMethod: RecoveryMethod;
+};
 export type OpenfortUIOptionsExtended = {
     theme: Theme;
     mode: Mode;
@@ -135,5 +127,6 @@ export type OpenfortUIOptionsExtended = {
     walletOnboardingUrl?: string;
     disableSiweRedirect?: boolean;
     overlayBlur?: number;
+    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,4 +1,4 @@
-import { OpenfortHookOptions, OpenfortError } from '../../../types';
+import { OpenfortError, OpenfortHookOptions } from '../../../types';
 export declare function useSignOut(hookOptions?: OpenfortHookOptions): {
     signOut: (options?: OpenfortHookOptions) => Promise<{}>;
     isLoading: boolean;

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

@@ -1,4 +1,4 @@
-import { AccountTypeEnum, RecoveryParams } 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";
@@ -12,6 +12,7 @@ export type UserWallet = {
     isAvailable: boolean;
     isActive?: boolean;
     isConnecting?: boolean;
+    recoveryMethod?: RecoveryMethod;
 };
 type SetActiveWalletResult = {
     error?: OpenfortError;